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

cms_qe_analytical/tests/test_tag_piwik.py

@@ -0,0 +1,152 @@
+"""
+Tests for the Piwik template tags and filters.
+"""
+
+from constance.test import override_config
+from django.contrib.auth import get_user_model
+from django.http import HttpRequest
+from django.template import Context
+from django.test.utils import override_settings
+
+from ..templatetags.piwik import PiwikNode
+from ..tests.utils import TagTestCase
+
+
+@override_config(PIWIK_DOMAIN_PATH='example.com', PIWIK_SITE_ID='345')
+class PiwikTagTestCase(TagTestCase):
+    """
+    Tests for the ``piwik`` template tag.
+    """
+
+    def test_tag(self):
+        r = self.render_tag('piwik', 'piwik')
+        self.assertTrue(' ? "https" : "http") + "://example.com/";' in r, r)
+        self.assertTrue("_paq.push(['setSiteId', 345]);" in r, r)
+        self.assertTrue('img src="http://example.com/matomo.php?idsite=345"'
+                        in r, r)
+
+    def test_node(self):
+        r = PiwikNode().render(Context({}))
+        self.assertTrue(' ? "https" : "http") + "://example.com/";' in r, r)
+        self.assertTrue("_paq.push(['setSiteId', 345]);" in r, r)
+        self.assertTrue('img src="http://example.com/matomo.php?idsite=345"'
+                        in r, r)
+
+    @override_config(PIWIK_DOMAIN_PATH='example.com/piwik',
+                     PIWIK_SITE_ID='345')
+    def test_domain_path_valid(self):
+        r = self.render_tag('piwik', 'piwik')
+        self.assertTrue(' ? "https" : "http") + "://example.com/piwik/";' in r,
+                        r)
+
+    @override_config(PIWIK_DOMAIN_PATH='example.com:1234',
+                     PIWIK_SITE_ID='345')
+    def test_domain_port_valid(self):
+        r = self.render_tag('piwik', 'piwik')
+        self.assertTrue(' ? "https" : "http") + "://example.com:1234/";' in r,
+                        r)
+
+    @override_config(PIWIK_DOMAIN_PATH='example.com:1234/piwik',
+                     PIWIK_SITE_ID='345')
+    def test_domain_port_path_valid(self):
+        r = self.render_tag('piwik', 'piwik')
+        self.assertTrue(' ? "https" : "http") + "://example.com:1234/piwik/";' in r,
+                        r)
+
+    @override_config(PIWIK_DOMAIN_PATH='')
+    def test_no_domain(self):
+        self.assertEqual(PiwikNode().render({}), '')
+
+    @override_config(PIWIK_SITE_ID='')
+    def test_no_siteid(self):
+        self.assertEqual(PiwikNode().render({}), '')
+
+    @override_config(PIWIK_SITE_ID='x')
+    def test_siteid_not_a_number(self):
+        self.assertEqual(PiwikNode().render({}), '')
+
+    @override_config(PIWIK_DOMAIN_PATH='http://www.example.com')
+    def test_domain_protocol_invalid(self):
+        self.assertEqual(PiwikNode().render({}), '')
+
+    @override_config(PIWIK_DOMAIN_PATH='example.com/')
+    def test_domain_slash_invalid(self):
+        self.assertEqual(PiwikNode().render({}), '')
+
+    @override_config(PIWIK_DOMAIN_PATH='example.com:123:456')
+    def test_domain_multi_port(self):
+        self.assertEqual(PiwikNode().render({}), '')
+
+    @override_config(PIWIK_DOMAIN_PATH='example.com:')
+    def test_domain_incomplete_port(self):
+        self.assertEqual(PiwikNode().render({}), '')
+
+    @override_config(PIWIK_DOMAIN_PATH='example.com:/piwik')
+    def test_domain_uri_incomplete_port(self):
+        self.assertEqual(PiwikNode().render({}), '')
+
+    @override_config(PIWIK_DOMAIN_PATH='example.com:12df')
+    def test_domain_port_invalid(self):
+        self.assertEqual(PiwikNode().render({}), '')
+
+    @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 = PiwikNode().render(context)
+        self.assertTrue(r.startswith(
+            '<!-- Piwik disabled on internal IP address'), r)
+        self.assertTrue(r.endswith('-->'), r)
+
+    def test_uservars(self):
+        context = Context({'piwik_vars': [(1, 'foo', 'foo_val'),
+                                          (2, 'bar', 'bar_val', 'page'),
+                                          (3, 'spam', 'spam_val', 'visit')]})
+        r = PiwikNode().render(context)
+        msg = 'Incorrect Piwik custom variable rendering. Expected:\n%s\nIn:\n%s'
+        for var_code in ['_paq.push(["setCustomVariable", 1, "foo", "foo_val", "page"]);',
+                         '_paq.push(["setCustomVariable", 2, "bar", "bar_val", "page"]);',
+                         '_paq.push(["setCustomVariable", 3, "spam", "spam_val", "visit"]);']:
+            self.assertIn(var_code, r, msg % (var_code, r))
+
+    @override_settings(ANALYTICAL_AUTO_IDENTIFY=True)
+    def test_default_usertrack(self):
+        User = get_user_model()
+        context = Context({
+            'user': User(username='BDFL', first_name='Guido', last_name='van Rossum')
+        })
+        r = PiwikNode().render(context)
+        msg = 'Incorrect Piwik user tracking rendering.\nNot found:\n%s\nIn:\n%s'
+        var_code = '_paq.push(["setUserId", "BDFL"]);'
+        self.assertIn(var_code, r, msg % (var_code, r))
+
+    def test_piwik_usertrack(self):
+        context = Context({
+            'piwik_identity': 'BDFL'
+        })
+        r = PiwikNode().render(context)
+        msg = 'Incorrect Piwik user tracking rendering.\nNot found:\n%s\nIn:\n%s'
+        var_code = '_paq.push(["setUserId", "BDFL"]);'
+        self.assertIn(var_code, r, msg % (var_code, r))
+
+    def test_analytical_usertrack(self):
+        context = Context({
+            'analytical_identity': 'BDFL'
+        })
+        r = PiwikNode().render(context)
+        msg = 'Incorrect Piwik user tracking rendering.\nNot found:\n%s\nIn:\n%s'
+        var_code = '_paq.push(["setUserId", "BDFL"]);'
+        self.assertIn(var_code, r, msg % (var_code, r))
+
+    @override_settings(ANALYTICAL_AUTO_IDENTIFY=True)
+    def test_disable_usertrack(self):
+        User = get_user_model()
+        context = Context({
+            'user': User(username='BDFL', first_name='Guido', last_name='van Rossum'),
+            'piwik_identity': None
+        })
+        r = PiwikNode().render(context)
+        msg = 'Incorrect Piwik user tracking rendering.\nFound:\n%s\nIn:\n%s'
+        var_code = '_paq.push(["setUserId", "BDFL"]);'
+        self.assertNotIn(var_code, r, msg % (var_code, r))

cms_qe_analytical/tests/test_utils.py

@@ -0,0 +1,112 @@
+"""
+Tests for the analytical.utils module.
+"""
+# import django
+
+from django.contrib.auth.models import AbstractBaseUser
+from django.db import models
+from django.http import HttpRequest
+from django.template import Context
+from django.test.utils import override_settings
+
+from ..tests.utils import TestCase
+from ..utils import AnalyticalException, get_domain, get_identity, get_required_setting, is_internal_ip
+
+
+class SettingDeletedTestCase(TestCase):
+
+    @override_settings(USER_ID=None)
+    def test_get_required_setting(self):
+        """
+        Make sure using get_required_setting fails in the right place.
+        """
+
+        # available in python >= 3.2
+        if hasattr(self, 'assertRaisesRegex'):
+            with self.assertRaisesRegex(AnalyticalException, "USER_ID"):
+                get_required_setting("USER_ID", r"\d+", "invalid USER_ID")
+        else:
+            self.assertRaises(AnalyticalException,
+                              get_required_setting, "USER_ID", r"\d+", "invalid USER_ID")
+
+
+class MyUser(AbstractBaseUser):
+    identity = models.CharField(max_length=50)
+    USERNAME_FIELD = 'identity'
+
+
+class GetIdentityTestCase(TestCase):
+    def test_custom_username_field(self):
+        get_id = get_identity(Context({}), user=MyUser(identity='fake_id'))
+        self.assertEqual(get_id, 'fake_id')
+
+
+@override_settings(ANALYTICAL_DOMAIN="example.org")
+class GetDomainTestCase(TestCase):
+    def test_get_service_domain_from_context(self):
+        context = Context({'test_domain': 'example.com'})
+        self.assertEqual(get_domain(context, 'test'), 'example.com')
+
+    def test_get_analytical_domain_from_context(self):
+        context = Context({'analytical_domain': 'example.com'})
+        self.assertEqual(get_domain(context, 'test'), 'example.com')
+
+    @override_settings(TEST_DOMAIN="example.net")
+    def test_get_service_domain_from_settings(self):
+        context = Context()
+        self.assertEqual(get_domain(context, 'test'), 'example.net')
+
+    def test_get_analytical_domain_from_settings(self):
+        context = Context()
+        self.assertEqual(get_domain(context, 'test'), 'example.org')
+
+
+class InternalIpTestCase(TestCase):
+
+    @override_settings(ANALYTICAL_INTERNAL_IPS=['1.1.1.1'])
+    def test_render_no_internal_ip(self):
+        context = Context()
+        self.assertFalse(is_internal_ip(context))
+
+    @override_settings(INTERNAL_IPS=['1.1.1.1'])
+    @override_settings(ANALYTICAL_INTERNAL_IPS=[])
+    def test_render_analytical_internal_ips_override_when_empty(self):
+        req = HttpRequest()
+        req.META['REMOTE_ADDR'] = '1.1.1.1'
+        context = Context({'request': req})
+        self.assertFalse(is_internal_ip(context))
+
+    @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})
+        self.assertTrue(is_internal_ip(context))
+
+    @override_settings(TEST_INTERNAL_IPS=['1.1.1.1'])
+    def test_render_prefix_internal_ip(self):
+        req = HttpRequest()
+        req.META['REMOTE_ADDR'] = '1.1.1.1'
+        context = Context({'request': req})
+        self.assertTrue(is_internal_ip(context, 'TEST'))
+
+    @override_settings(INTERNAL_IPS=['1.1.1.1'])
+    def test_render_internal_ip_fallback(self):
+        req = HttpRequest()
+        req.META['REMOTE_ADDR'] = '1.1.1.1'
+        context = Context({'request': req})
+        self.assertTrue(is_internal_ip(context))
+
+    @override_settings(ANALYTICAL_INTERNAL_IPS=['1.1.1.1'])
+    def test_render_internal_ip_forwarded_for(self):
+        req = HttpRequest()
+        req.META['HTTP_X_FORWARDED_FOR'] = '1.1.1.1'
+        context = Context({'request': req})
+        self.assertTrue(is_internal_ip(context))
+
+    @override_settings(ANALYTICAL_INTERNAL_IPS=['1.1.1.1'])
+    def test_render_different_internal_ip(self):
+        req = HttpRequest()
+        req.META['REMOTE_ADDR'] = '2.2.2.2'
+        context = Context({'request': req})
+        self.assertFalse(is_internal_ip(context))

cms_qe_analytical/tests/utils.py

@@ -0,0 +1,56 @@
+"""
+Testing utilities.
+"""
+
+
+from django.template import Context, RequestContext, Template
+from django.test.testcases import TestCase
+
+
+def run_tests():
+    """
+    Use the Django test runner to run the tests.
+
+    Sets the return code to the number of failed tests.
+    """
+    import sys
+
+    import django
+    try:
+        django.setup()
+    except AttributeError:
+        pass
+    try:
+        from django.test.runner import DiscoverRunner as TestRunner
+    except ImportError:
+        from django.test.simple import DjangoTestSuiteRunner as TestRunner
+    runner = TestRunner()
+    sys.exit(runner.run_tests(["analytical"]))
+
+
+class TagTestCase(TestCase):
+    """
+    Tests for a template tag.
+
+    Adds support methods for testing template tags.
+    """
+
+    def render_tag(self, library, tag, vars=None, request=None):
+        if vars is None:
+            vars = {}
+        t = Template(f"{{% load {library} %}}{{% {tag} %}}")
+        if request is not None:
+            context = RequestContext(request, vars)
+        else:
+            context = Context(vars)
+        return t.render(context)
+
+    def render_template(self, template, vars=None, request=None):
+        if vars is None:
+            vars = {}
+        t = Template(template)
+        if request is not None:
+            context = RequestContext(request, vars)
+        else:
+            context = Context(vars)
+        return t.render(context)

cms_qe_auth/tests/test_models.py

@@ -0,0 +1,70 @@
+import re
+
+from django.test import override_settings
+from django.urls.converters import SlugConverter
+from pytest_data import use_data
+
+from cms_qe_auth.models import User
+from cms_qe_auth.tests.utils import reset_urls
+from cms_qe_auth.utils import pk_to_uidb64
+
+
+def test_set_username_by_email():
+    user = User(email='user@example.com')
+    assert not user.username
+    user.save()
+    assert user.username == user.email
+
+
+@use_data(user_data={'username': 'user@example.com', 'email': 'user@example.com'})
+def test_set_username_by_changing_email(user):
+    assert user.username == 'user@example.com'
+    user.email = 'another@example.com'
+    assert user.username == 'user@example.com'
+    user.save()
+    assert user.username == 'another@example.com'
+
+
+@use_data(user_data={'email': 'user@example.com'})
+def test_unset_is_active_by_changing_email(user):
+    assert user.is_active
+    user.email = 'another@example.com'
+    assert user.is_active
+    user.save()
+    assert not user.is_active
+
+
+def test_simple_token_generation_and_checking(user):
+    token = user._generate_activation_token()
+    assert user._check_activation_token(token)
+
+
+@use_data(user_data={'is_active': False})
+def test_simple_token_generation_and_activate_is_active(user):
+    assert not user.is_active
+    token = user._generate_activation_token()
+    user.activate(token)
+    assert user.is_active
+
+
+@use_data(user_data={'is_active': False})
+def test_simple_token_generation_and_activate_invalid(user):
+    user._generate_activation_token()
+    assert not user.activate("123456789ABZ-987654321abcdefg")
+    assert not user.is_active
+
+
+@override_settings(CMS_QE_AUTH_ENABLED=True)
+def test_activation_email_sending(mailoutbox):
+    reset_urls()
+    user = User(username='testuser', email='testuser@example.com', is_active=False)
+    user.save(base_url="http://example.com")
+    assert len(mailoutbox) == 1
+    email = mailoutbox[0]
+    assert user.email == email.to[0]
+    assert 'activate' in email.subject.lower()
+    token_re = f'(?P<token>{SlugConverter.regex})'
+    url_re = fr'//example.com/en/auth/activate/{pk_to_uidb64(user.pk)}/{token_re}'
+    match = re.findall(url_re, email.body)
+    assert match
+    assert user._check_activation_token(match[0])

cms_qe_auth/tests/test_utils.py

@@ -0,0 +1,36 @@
+import pytest
+from pytest_data import use_data
+
+from ..utils import get_user_by_uidb64, pk_to_uidb64, uidb64_to_pk
+
+UIDB64_TEST_DATA = (
+    'pk, uid',
+    [
+        ('1', 'MQ'),
+        ('99', 'OTk'),
+        ('100', 'MTAw'),
+        ('123456', 'MTIzNDU2')
+    ]
+)
+
+
+@pytest.mark.parametrize(*UIDB64_TEST_DATA)
+def test_uidb64_to_pk(pk, uid):
+    assert uidb64_to_pk(uid) == pk
+
+
+@pytest.mark.parametrize(*UIDB64_TEST_DATA)
+def test_pk_to_uidb64(pk, uid):
+    assert pk_to_uidb64(pk) == uid
+
+
+@use_data(user_data={'id': 1})
+def test_get_user_by_uidb64(user):
+    assert user.pk == 1
+    assert user == get_user_by_uidb64("MQ")
+
+
+@use_data(user_data={'id': 1})
+def test_get_user_by_uidb64_user_not_exits(user):
+    user = get_user_by_uidb64("Mg")
+    assert not user

cms_qe_auth/tests/test_view.py

@@ -0,0 +1,72 @@
+import re
+
+from django.contrib.auth import get_user_model
+from django.test import override_settings
+from pytest_data import use_data
+
+from cms_qe_auth.tests.utils import reset_urls
+
+
+@override_settings(CMS_QE_AUTH_ENABLED=True)
+@use_data(user_data={'username': 'testuser', 'password': 'testpass'})
+def test_login(client, user):
+    reset_urls()
+    res = client.post('/en/auth/login/', {'username': 'testuser', 'password': 'testpass'})
+    assert res.status_code == 302
+
+
+@override_settings(CMS_QE_AUTH_ENABLED=True)
+def test_register(mailoutbox, client):
+    assert len(mailoutbox) == 0
+    assert not get_user_model().objects.filter(username='testuser')
+
+    reset_urls()
+    user = _register_user(client)
+
+    assert user.email == 'testuser@example.com'
+    assert len(mailoutbox) == 1
+    activation_mail = mailoutbox[0]
+    assert 'activate' in activation_mail.body
+    assert 'http' in activation_mail.body
+
+
+@override_settings(AUTHENTICATION_BACKENDS=[
+    'django.contrib.auth.backends.ModelBackend',
+    'cms_qe_auth.tests.utils.TestAuthBackend',
+], CMS_QE_AUTH_ENABLED=True)
+def test_activation_multiple_authentication_backends(client, mailoutbox):
+    _test_activation(client, mailoutbox)
+
+
+@override_settings(CMS_QE_AUTH_ENABLED=True)
+def test_activation(client, mailoutbox):
+    _test_activation(client, mailoutbox)
+
+
+def _test_activation(client, mailoutbox):
+    reset_urls()
+    user = get_user_model()(username='testuser', email='testuser@example.com', is_active=False)
+    user.save(base_url="http://example.com")
+
+    # Get activation link from email
+    activation_mail = mailoutbox[0]
+    activate_url_pattern = r'(?P<url>https?://[^\s]+/activate/[^\s]+)'
+    url = re.search(activate_url_pattern, activation_mail.body).group('url')
+
+    response = client.get(url)
+    user.refresh_from_db()
+
+    assert user.is_active
+    # Test automatic login
+    assert response.context['user'].is_authenticated
+
+
+def _register_user(client):
+    res = client.post('/en/auth/register/', {
+        'username': 'testuser',
+        'password1': '179ad45c6ce2cb97cf1029e212046e81',
+        'password2': '179ad45c6ce2cb97cf1029e212046e81',
+        'email': 'testuser@example.com',
+    })
+    assert res.status_code == 302
+    return get_user_model().objects.get(username='testuser')

cms_qe_auth/tests/utils.py

@@ -0,0 +1,22 @@
+import sys
+
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from django.contrib.auth.backends import ModelBackend
+from django.urls import clear_url_caches
+
+
+class TestAuthBackend(ModelBackend):
+    def authenticate(self, username=None, password=None):
+        User = get_user_model()
+        try:
+            user = User.objects.get(username=username)
+            return user
+        except User.DoesNotExist:
+            return
+
+
+def reset_urls():
+    """Reset Django site urls."""
+    del sys.modules[settings.ROOT_URLCONF]
+    clear_url_caches()

cms_qe_newsletter/tests/test_mailchimp.py

@@ -0,0 +1,38 @@
+import pytest
+from constance.test import override_config
+from django.conf import settings
+from mailchimp3.mailchimpclient import MailChimpError
+from pytest_data import use_data
+
+from ..external_services.mailchimp import sync_mailing_lists, sync_subscribe, sync_unsubscribe
+from ..models import MailingList
+
+
+@override_config(
+    MAILCHIMP_USERNAME=settings.TEST_MAILCHIMP_USERNAME,
+    MAILCHIMP_API_KEY=settings.TEST_MAILCHIMP_API_KEY,
+)
+def test_sync_mailing_lists_integrate():
+    with pytest.raises(MailChimpError) as exc_info:
+        _test_sync_mailing_lists()
+    assert exc_info.value.args[0]['title'] == 'API Key Invalid'
+
+
+def test_sync_mailing_lists(mock_mailchimp):
+    _test_sync_mailing_lists()
+
+
+def _test_sync_mailing_lists():
+    assert MailingList.objects.count() == 0
+    sync_mailing_lists()
+    assert MailingList.objects.count() == 2
+
+
+@use_data(cms_qe_mailchimp_subscribe_data={'id': 'subid'})
+def test_sync_subscribe(mock_mailchimp):
+    assert 'subid' == sync_subscribe('listid', 'test@example.com', 'first', 'last')
+
+
+def test_sync_unsubscribe(mock_mailchimp):
+    # No exception.
+    sync_unsubscribe('listid', 'test@example.com')

cms_qe_newsletter/tests/test_managment.py

@@ -0,0 +1,22 @@
+from unittest import mock
+
+
+def test_not_set_mailchimp():
+    with mock.patch('cms_qe_newsletter.external_services.sync.sync_tasks', return_value=[
+        (True, 'ok'),
+        (None, 'warning'),
+        (False, 'error'),
+    ]):
+        # Import here so mock works correctly.
+        from ..management.commands.cms_qe_newsletter_sync import Command
+
+        with mock.patch('cms_qe_newsletter.management.commands.cms_qe_newsletter_sync.logger') as log_mock:
+            command = Command()
+            command.handle()
+            assert log_mock.info.call_args_list == [
+                mock.call('Newsletter sync started...'),
+                mock.call('ok'),
+                mock.call('Newsletter sync finished...'),
+            ]
+            assert log_mock.warning.call_args_list == [mock.call('warning')]
+            assert log_mock.error.call_args_list == [mock.call('error')]

cms_qe_newsletter/tests/test_models.py

@@ -0,0 +1,43 @@
+import pytest
+from django.core.exceptions import ValidationError
+from pytest_data import use_data
+
+from ..models import SERVICE_MAILCHIMP, Subscriber, SubscribeTask
+
+
+def test_clean_newsletter_plugin(cms_qe_newsletter_plugin):
+    cms_qe_newsletter_plugin.fullname_show = False
+    cms_qe_newsletter_plugin.fullname_require = True
+    with pytest.raises(ValidationError):
+        cms_qe_newsletter_plugin.clean()
+
+
+def test_validate_mailing_list(cms_qe_mailing_list):
+    cms_qe_mailing_list.external_service = SERVICE_MAILCHIMP
+    cms_qe_mailing_list.external_id = None
+    with pytest.raises(ValidationError):
+        cms_qe_mailing_list.clean()
+
+
+def test_save_will_create_task(cms_qe_mailing_list):
+    sub = Subscriber(
+        mailing_list=cms_qe_mailing_list,
+        email='test@example.com',
+    )
+    assert SubscribeTask.objects.all().count() == 0
+    sub.save()
+    assert SubscribeTask.objects.all().count() == 1
+
+
+@use_data(cms_qe_subscriber_data={'external_id': 'test_id'})
+def test_delete_will_create_task(cms_qe_subscriber):
+    assert SubscribeTask.objects.all().count() == 0
+    cms_qe_subscriber.delete()
+    assert SubscribeTask.objects.all().count() == 1
+
+
+@use_data(cms_qe_subscriber_data={'external_id': None})
+def test_delete_will_remove_pending_task(cms_qe_subscriber):
+    assert SubscribeTask.objects.all().count() == 1
+    cms_qe_subscriber.delete()
+    assert SubscribeTask.objects.all().count() == 0

cms_qe_newsletter/tests/test_plugin.py

@@ -0,0 +1,21 @@
+from cms_qe_test import render_plugin
+
+from ..cms_plugins import NewsletterPlugin
+
+
+def test_render():
+    html = render_plugin(NewsletterPlugin)
+    assert '<form' in html
+    assert '<input' in html
+    assert 'email' in html
+    assert 'first' not in html
+    assert 'last' not in html
+    assert 'submit' in html
+
+
+def test_render_fullname_show():
+    html = render_plugin(NewsletterPlugin, fullname_show=True)
+    assert 'email' in html
+    assert 'first' in html
+    assert 'last' in html
+    assert 'submit' in html