Use correct filenames for the tests (and split some)

tests/unit/test_factories.py

@@ -15,7 +15,7 @@ from wagtail_personalisation.rules import TimeRule
 # Factory tests
 
 @pytest.mark.django_db
-def test_create_segment_factory():
+def test_segment_create():
     factoried_segment = SegmentFactory()
     segment = Segment(name='TestSegment', status='enabled')
     TimeRule(
@@ -27,75 +27,13 @@ def test_create_segment_factory():
     assert factoried_segment.status == segment.status
 
 
-# TimeRuleFactory tests
+
 
 @pytest.mark.django_db
-def test_create_segment_with_time_rule():
+def test_referral_rule_create():
-    segment = SegmentFactory(name='TimeSegment')
-    time_rule = TimeRuleFactory(
-        start_time=datetime.time(8, 0, 0),
-        end_time=datetime.time(23, 0, 0),
-        segment=segment)
-
-    assert time_rule.start_time == datetime.time(8, 0, 0)
-
-
-# TimeRuleFactory tests
-
-@pytest.mark.django_db
-def test_create_segment_with_day_rule():
-    segment = SegmentFactory(name='DaySegment')
-    day_rule = DayRuleFactory(mon=True, thu=True, segment=segment)
-
-    assert day_rule.mon is True
-    assert day_rule.thu is True
-    assert day_rule.sun is False
-
-
-# DeviceRuleFactory tests
-
-@pytest.mark.django_db
-def test_create_segment_with_device_rule():
-    segment = SegmentFactory(name='DeviceSegment')
-    device_rule = DeviceRuleFactory(mobile=True, segment=segment)
-
-    assert device_rule.mobile is True
-    assert device_rule.tablet is False
-    assert device_rule.desktop is False
-
-
-# ReferralRuleFactory tests
-
-@pytest.mark.django_db
-def test_create_segment_with_referral_rule():
     segment = SegmentFactory(name='Referral')
     referral_rule = ReferralRuleFactory(
         regex_string='test.test',
         segment=segment)
 
     assert referral_rule.regex_string == 'test.test'
-
-
-@pytest.mark.django_db
-def test_create_segment_with_new_referral_rule():
-    segment = SegmentFactory()
-
-    segment.referral_rule = ReferralRuleFactory(
-        regex_string='test.notest',
-        segment=segment)
-
-    assert segment.referral_rule.regex_string == 'test.notest'
-
-
-@pytest.mark.django_db
-def test_site_factory():
-    site = SiteFactory()
-    assert site
-
-
-@pytest.mark.django_db
-def test_page_factory():
-    site = SiteFactory()
-    assert site.root_page
-    page = ContentPageFactory(parent=site.root_page)
-    assert page.get_parent() == site.root_page

tests/unit/test_middleware.py

@@ -1,277 +0,0 @@
-from __future__ import absolute_import, unicode_literals
-
-import datetime
-
-import pytest
-from freezegun import freeze_time
-
-from tests.factories.rule import (
-    DayRuleFactory, DeviceRuleFactory, QueryRuleFactory, ReferralRuleFactory,
-    TimeRuleFactory, VisitCountRuleFactory)
-from tests.factories.segment import SegmentFactory
-from tests.factories.site import SiteFactory
-
-
-@pytest.mark.django_db
-class TestUserSegmenting(object):
-
-    def setup(self):
-        """
-        Sets up a site root to test segmenting
-        """
-        self.site = SiteFactory(is_default_site=True)
-
-    def test_no_segments(self, client):
-        client.get('/')
-
-        assert client.session['segments'] == []
-
-    @freeze_time("10:00:00")
-    def test_time_segment(self, client):
-        time_only_segment = SegmentFactory(name='Time only')
-        TimeRuleFactory(
-            start_time=datetime.time(8, 0, 0),
-            end_time=datetime.time(23, 0, 0),
-            segment=time_only_segment)
-
-        client.get('/')
-
-        assert client.session['segments'][0]['encoded_name'] == 'time-only'
-
-    @freeze_time("2017-01-01")
-    def test_day_segment(self, client):
-        day_only_segment = SegmentFactory(name='Day only')
-        DayRuleFactory(
-            sun=True,
-            segment=day_only_segment)
-
-        client.get('/')
-
-        assert client.session['segments'][0]['encoded_name'] == 'day-only'
-
-    def test_device_segment(self, client):
-        device_only_segment = SegmentFactory(name='Device only')
-        DeviceRuleFactory(
-            tablet=True,
-            segment=device_only_segment)
-
-        client.get('/', **{'HTTP_USER_AGENT': 'Mozilla/5.0(iPad; U; CPU iPhone OS 3_2 like Mac OS X)'})
-
-        assert client.session['segments'][0]['encoded_name'] == 'device-only'
-
-    def test_device_segment_no_match(self, client):
-        no_device_segment = SegmentFactory(name='No device')
-        DeviceRuleFactory(
-            mobile=True,
-            segment=no_device_segment)
-
-        client.get('/', **{'HTTP_USER_AGENT': 'Mozilla/5.0(iPad; U; CPU iPhone OS 3_2 like Mac OS X)'})
-
-        assert not client.session['segments']
-
-    def test_referral_segment(self, client):
-        referral_segment = SegmentFactory(name='Referral')
-        ReferralRuleFactory(
-            regex_string="test.test",
-            segment=referral_segment
-        )
-
-        client.get('/', **{'HTTP_REFERER': 'test.test'})
-
-        assert client.session['segments'][0]['encoded_name'] == 'referral'
-
-    @freeze_time("10:00:00")
-    def test_time_and_referral_segment(self, client):
-        segment = SegmentFactory(name='Both')
-        TimeRuleFactory(
-            start_time=datetime.time(8, 0, 0),
-            end_time=datetime.time(23, 0, 0),
-            segment=segment
-        )
-        ReferralRuleFactory(
-            regex_string="test.test",
-            segment=segment
-        )
-
-        client.get('/', **{'HTTP_REFERER': 'test.test'})
-
-        assert client.session['segments'][0]['encoded_name'] == 'both'
-
-    @freeze_time("7:00:00")
-    def test_no_time_but_referral_segment(self, client):
-        segment = SegmentFactory(name='Not both')
-        TimeRuleFactory(
-            start_time=datetime.time(8, 0, 0),
-            end_time=datetime.time(23, 0, 0),
-            segment=segment
-        )
-        ReferralRuleFactory(
-            regex_string="test.test",
-            segment=segment
-        )
-
-        client.get('/', **{'HTTP_REFERER': 'test.test'})
-
-        assert len(client.session['segments']) == 0
-
-    @freeze_time("9:00:00")
-    def test_time_but_no_referral_segment(self, client):
-        segment = SegmentFactory(name='Not both')
-        TimeRuleFactory(
-            start_time=datetime.time(8, 0, 0),
-            end_time=datetime.time(23, 0, 0),
-            segment=segment
-        )
-        ReferralRuleFactory(
-            regex_string="test.test",
-            segment=segment
-        )
-
-        client.get('/')
-
-        assert len(client.session['segments']) == 0
-
-    @freeze_time("9:00:00")
-    def test_multiple_segments_exist(self, client):
-        first_segment = SegmentFactory(name='First')
-        second_segment = SegmentFactory(name='Second')
-
-        TimeRuleFactory(
-            start_time=datetime.time(8, 0, 0),
-            end_time=datetime.time(23, 0, 0),
-            segment=first_segment
-        )
-        ReferralRuleFactory(
-            regex_string="test.test",
-            segment=first_segment
-        )
-
-        TimeRuleFactory(
-            start_time=datetime.time(8, 0, 0),
-            end_time=datetime.time(23, 0, 0),
-            segment=second_segment
-        )
-
-    def test_visit_count_rule(self, client):
-        segment = SegmentFactory(name='Visit Count')
-
-        VisitCountRuleFactory(
-            counted_page=self.site.root_page,
-            segment=segment
-        )
-
-        client.get("/root")
-
-        # assert any(item['encoded_name'] == 'visit-count' for item in client.session['segments'])
-
-    def test_query_rule(self, client):
-        segment = SegmentFactory(name='Query')
-        QueryRuleFactory(
-            parameter="query",
-            value="value",
-            segment=segment,
-        )
-
-        client.get('/?query=value')
-
-        assert any(item['encoded_name'] == 'query' for item in client.session['segments'])
-
-    def test_only_one_query_rule(self, client):
-        segment = SegmentFactory(name='Query')
-        QueryRuleFactory(
-            parameter="query",
-            value="value",
-            segment=segment
-        )
-
-        client.get('/?test=test&query=value')
-
-        assert any(item['encoded_name'] == 'query' for item in client.session['segments'])
-
-    def test_multiple_queries(self, client):
-        segment = SegmentFactory(name='Multiple queries')
-        QueryRuleFactory(
-            parameter="test",
-            value="test",
-            segment=segment
-        )
-
-        QueryRuleFactory(
-            parameter="query",
-            value="value",
-            segment=segment,
-        )
-
-        client.get('/?test=test&query=value')
-
-        assert any(item['encoded_name'] == 'multiple-queries' for item in client.session['segments'])
-
-    def test_persistent_segmenting(self, client):
-        segment = SegmentFactory(name='Persistent', persistent=True)
-        QueryRuleFactory(
-            parameter="test",
-            value="test",
-            segment=segment
-        )
-
-        client.get('/?test=test')
-
-        assert any(item['encoded_name'] == 'persistent' for item in client.session['segments'])
-
-        client.get('/')
-
-        assert any(item['encoded_name'] == 'persistent' for item in client.session['segments'])
-
-    def test_non_persistent_segmenting(self, client):
-        segment = SegmentFactory(name='Non Persistent')
-        QueryRuleFactory(
-            parameter="test",
-            value="test",
-            segment=segment
-        )
-
-        client.get('/?test=test')
-
-        assert any(item['encoded_name'] == 'non-persistent' for item in client.session['segments'])
-
-        client.get('/')
-
-        assert not any(item['encoded_name'] == 'non-persistent' for item in client.session['segments'])
-
-    def test_match_any_segmenting(self, client):
-        segment = SegmentFactory(name='Match any', match_any=True)
-        QueryRuleFactory(
-            parameter='test',
-            value='test',
-            segment=segment,
-        )
-        QueryRuleFactory(
-            parameter='test2',
-            value='test2',
-            segment=segment
-        )
-
-        client.get('/?test=test')
-
-        assert any(item['encoded_name'] == 'match-any' for item in client.session['segments'])
-
-
-@pytest.mark.django_db
-def test_visit_count(site, client):
-    response = client.get('/')
-    assert response.status_code == 200
-    visit_count = client.session['visit_count']
-    assert visit_count[0]['path'] == '/'
-    assert visit_count[0]['count'] == 1
-
-    response = client.get('/')
-    assert response.status_code == 200
-    visit_count = client.session['visit_count']
-    assert visit_count[0]['path'] == '/'
-    assert visit_count[0]['count'] == 2
-
-    response = client.get('/page-1/')
-    assert response.status_code == 200
-    visit_count = client.session['visit_count']
-    assert visit_count[0]['count'] == 2
-    assert visit_count[1]['count'] == 1

tests/unit/test_models.py

@@ -3,66 +3,22 @@ from __future__ import absolute_import, unicode_literals
 import datetime
 
 import pytest
-from django.http import HttpRequest
-from freezegun import freeze_time
-from wagtail.wagtailcore.models import Site
 
-from wagtail_personalisation import rules
+from tests.factories.segment import SegmentFactory
-
+from wagtail_personalisation.rules import TimeRule
-
-# Time Rule tests
-
-@freeze_time("10:00:00")
-def test_create_time_rule():
-    time_rule = rules.TimeRule(start_time=datetime.time(8, 0, 0), end_time=datetime.time(23, 0, 0))
-
-    assert time_rule.test_user() is True
-
-
-@freeze_time("10:00:00")
-def test_time_rule_false():
-    time_rule = rules.TimeRule(start_time=datetime.time(11, 0, 0), end_time=datetime.time(23, 0, 0))
-
-    assert time_rule.test_user() is False
-
-
-@freeze_time("10:00:00")
-def test_time_rule_reverse():
-    time_rule = rules.TimeRule(start_time=datetime.time(13, 0, 0), end_time=datetime.time(9, 0, 0))
-
-    assert time_rule.test_user() is False
-
-
-@freeze_time("10:00:00")
-def test_time_rule_reverse_next_day():
-    time_rule = rules.TimeRule(start_time=datetime.time(11, 0, 0), end_time=datetime.time(11, 0, 0))
-
-    assert time_rule.test_user() is False
-
-
-# Visit Count Rule tests
-def test_visit_count_rule():
-    rules.VisitCountRule()
-
-
-# Test test
-
-@pytest.mark.django_db
-def test_test(rf, site):
-    request = HttpRequest()
-    request.path = '/'
-    request.META['HTTP_HOST'] = 'localhost'
-    request.META['SERVER_PORT'] = 8000
-
-    assert Site.find_for_request(request) == site
 
 
 @pytest.mark.django_db
-class TestPage(object):
+def test_segment_create():
-    def test_page_copy_for_segment(self, segmented_page):
+    segment = SegmentFactory()
-        assert segmented_page
+    TimeRule(
+        start_time=datetime.time(8, 0, 0),
+        end_time=datetime.time(23, 0, 0),
+        segment=segment)
 
-    def test_page_has_variations(self, segmented_page):
+
+@pytest.mark.django_db
+def test_metadata_page_has_variations(segmented_page):
     assert not segmented_page.personalisable_metadata.is_canonical
     assert not segmented_page.personalisable_metadata.has_variations
 

tests/unit/test_rules_day.py

@@ -0,0 +1,30 @@
+from __future__ import absolute_import, unicode_literals
+
+import pytest
+from freezegun import freeze_time
+
+from tests.factories.rule import DayRuleFactory
+from tests.factories.segment import SegmentFactory
+
+
+@pytest.mark.django_db
+def test_day_rule_create():
+    segment = SegmentFactory(name='DaySegment')
+    day_rule = DayRuleFactory(mon=True, thu=True, segment=segment)
+
+    assert day_rule.mon is True
+    assert day_rule.thu is True
+    assert day_rule.sun is False
+
+
+@pytest.mark.django_db
+@freeze_time("2017-01-01")
+def test_request_day_segment(client, site):
+    day_only_segment = SegmentFactory(name='Day only')
+    DayRuleFactory(
+        sun=True,
+        segment=day_only_segment)
+
+    client.get('/')
+
+    assert client.session['segments'][0]['encoded_name'] == 'day-only'

tests/unit/test_rules_device.py

@@ -0,0 +1,38 @@
+import pytest
+
+from tests.factories.rule import DeviceRuleFactory
+from tests.factories.segment import SegmentFactory
+
+
+@pytest.mark.django_db
+def test_device_rule_create():
+    segment = SegmentFactory(name='DeviceSegment')
+    device_rule = DeviceRuleFactory(mobile=True, segment=segment)
+
+    assert device_rule.mobile is True
+    assert device_rule.tablet is False
+    assert device_rule.desktop is False
+
+
+@pytest.mark.django_db
+def test_request_device_segment(client, site):
+    device_only_segment = SegmentFactory(name='Device only')
+    DeviceRuleFactory(
+        tablet=True,
+        segment=device_only_segment)
+
+    client.get('/', **{'HTTP_USER_AGENT': 'Mozilla/5.0(iPad; U; CPU iPhone OS 3_2 like Mac OS X)'})
+
+    assert client.session['segments'][0]['encoded_name'] == 'device-only'
+
+
+@pytest.mark.django_db
+def test_request_device_segment_no_match(client, site):
+    no_device_segment = SegmentFactory(name='No device')
+    DeviceRuleFactory(
+        mobile=True,
+        segment=no_device_segment)
+
+    client.get('/', **{'HTTP_USER_AGENT': 'Mozilla/5.0(iPad; U; CPU iPhone OS 3_2 like Mac OS X)'})
+
+    assert not client.session['segments']

tests/unit/test_rules_mixed.py

@@ -0,0 +1,90 @@
+from __future__ import absolute_import, unicode_literals
+
+import datetime
+
+import pytest
+from freezegun import freeze_time
+
+from tests.factories.rule import ReferralRuleFactory, TimeRuleFactory
+from tests.factories.segment import SegmentFactory
+
+
+@pytest.mark.django_db
+def test_no_segments(client, site):
+    response = client.get('/')
+    assert response.status_code == 200
+    assert client.session['segments'] == []
+
+
+@pytest.mark.django_db
+def test_referral_segment(client, site):
+    referral_segment = SegmentFactory(name='Referral')
+    ReferralRuleFactory(
+        regex_string="test.test",
+        segment=referral_segment
+    )
+
+    response = client.get('/', **{'HTTP_REFERER': 'test.test'})
+    assert response.status_code == 200
+
+    assert client.session['segments'][0]['encoded_name'] == 'referral'
+
+
+@pytest.mark.django_db
+@freeze_time("10:00:00")
+def test_time_and_referral_segment(client, site):
+    segment = SegmentFactory(name='Both')
+    TimeRuleFactory(
+        start_time=datetime.time(8, 0, 0),
+        end_time=datetime.time(23, 0, 0),
+        segment=segment
+    )
+    ReferralRuleFactory(
+        regex_string="test.test",
+        segment=segment
+    )
+
+    response = client.get('/', **{'HTTP_REFERER': 'test.test'})
+    assert response.status_code == 200
+
+    assert client.session['segments'][0]['encoded_name'] == 'both'
+
+
+@pytest.mark.django_db
+@freeze_time("7:00:00")
+def test_no_time_but_referral_segment(client, site):
+    segment = SegmentFactory(name='Not both')
+    TimeRuleFactory(
+        start_time=datetime.time(8, 0, 0),
+        end_time=datetime.time(23, 0, 0),
+        segment=segment
+    )
+    ReferralRuleFactory(
+        regex_string="test.test",
+        segment=segment
+    )
+
+    response = client.get('/', **{'HTTP_REFERER': 'test.test'})
+    assert response.status_code == 200
+
+    assert len(client.session['segments']) == 0
+
+
+@pytest.mark.django_db
+@freeze_time("9:00:00")
+def test_time_but_no_referral_segment(client, site):
+    segment = SegmentFactory(name='Not both')
+    TimeRuleFactory(
+        start_time=datetime.time(8, 0, 0),
+        end_time=datetime.time(23, 0, 0),
+        segment=segment
+    )
+    ReferralRuleFactory(
+        regex_string="test.test",
+        segment=segment
+    )
+
+    response = client.get('/')
+    assert response.status_code == 200
+
+    assert len(client.session['segments']) == 0

tests/unit/test_rules_query.py

@@ -0,0 +1,126 @@
+import pytest
+
+from tests.factories.rule import QueryRuleFactory
+from tests.factories.segment import SegmentFactory
+
+
+@pytest.mark.django_db
+def test_request_query_rule(client, site):
+    segment = SegmentFactory(name='Query')
+    QueryRuleFactory(
+        parameter="query",
+        value="value",
+        segment=segment,
+    )
+
+    response = client.get('/?query=value')
+    assert response.status_code == 200
+
+    assert any(
+        item['encoded_name'] == 'query' for item in client.session['segments'])
+
+
+@pytest.mark.django_db
+def test_request_only_one_query_rule(client, site):
+    segment = SegmentFactory(name='Query')
+    QueryRuleFactory(
+        parameter="query",
+        value="value",
+        segment=segment
+    )
+
+    response = client.get('/?test=test&query=value')
+    assert response.status_code == 200
+    assert any(
+        item['encoded_name'] == 'query' for item in client.session['segments'])
+
+
+@pytest.mark.django_db
+def test_request_multiple_queries(client, site):
+    segment = SegmentFactory(name='Multiple queries')
+    QueryRuleFactory(
+        parameter="test",
+        value="test",
+        segment=segment
+    )
+
+    QueryRuleFactory(
+        parameter="query",
+        value="value",
+        segment=segment,
+    )
+
+    response = client.get('/?test=test&query=value')
+    assert response.status_code == 200
+    assert any(
+        item['encoded_name'] == 'multiple-queries'
+        for item in client.session['segments']
+    )
+
+
+@pytest.mark.django_db
+def test_request_persistent_segmenting(client, site):
+    segment = SegmentFactory(name='Persistent', persistent=True)
+    QueryRuleFactory(
+        parameter="test",
+        value="test",
+        segment=segment
+    )
+
+    response = client.get('/?test=test')
+    assert response.status_code == 200
+
+    assert any(
+        item['encoded_name'] == 'persistent'
+        for item in client.session['segments'])
+
+    response = client.get('/')
+    assert response.status_code == 200
+    assert any(
+        item['encoded_name'] == 'persistent'
+        for item in client.session['segments'])
+
+
+@pytest.mark.django_db
+def test_request_non_persistent_segmenting(client, site):
+    segment = SegmentFactory(name='Non Persistent')
+    QueryRuleFactory(
+        parameter="test",
+        value="test",
+        segment=segment
+    )
+
+    response = client.get('/?test=test')
+    assert response.status_code == 200
+    assert any(
+        item['encoded_name'] == 'non-persistent'
+        for item in client.session['segments'])
+
+    response = client.get('/')
+    assert response.status_code == 200
+
+    assert not any(
+        item['encoded_name'] == 'non-persistent'
+        for item in client.session['segments'])
+
+
+@pytest.mark.django_db
+def test_request_match_any_segmenting(client, site):
+    segment = SegmentFactory(name='Match any', match_any=True)
+    QueryRuleFactory(
+        parameter='test',
+        value='test',
+        segment=segment,
+    )
+    QueryRuleFactory(
+        parameter='test2',
+        value='test2',
+        segment=segment
+    )
+
+    response = client.get('/?test=test')
+    assert response.status_code == 200
+
+    assert any(
+        item['encoded_name'] == 'match-any'
+        for item in client.session['segments'])

tests/unit/test_rules_referral.py

@@ -0,0 +1,15 @@
+
+import pytest
+
+from tests.factories.rule import ReferralRuleFactory
+from tests.factories.segment import SegmentFactory
+
+
+@pytest.mark.django_db
+def test_referral_rule_create():
+    segment = SegmentFactory(name='Referral')
+    referral_rule = ReferralRuleFactory(
+        regex_string='test.test',
+        segment=segment)
+
+    assert referral_rule.regex_string == 'test.test'

tests/unit/test_rules_time.py

@@ -0,0 +1,31 @@
+import datetime
+
+import pytest
+from freezegun import freeze_time
+
+from tests.factories.rule import TimeRuleFactory
+from tests.factories.segment import SegmentFactory
+
+
+@pytest.mark.django_db
+def test_time_rule_create():
+    segment = SegmentFactory(name='TimeSegment')
+    time_rule = TimeRuleFactory(
+        start_time=datetime.time(8, 0, 0),
+        end_time=datetime.time(23, 0, 0),
+        segment=segment)
+
+    assert time_rule.start_time == datetime.time(8, 0, 0)
+@pytest.mark.django_db
+@freeze_time("10:00:00")
+def test_requesttime_segment(client, site):
+    time_only_segment = SegmentFactory(name='Time only')
+    TimeRuleFactory(
+        start_time=datetime.time(8, 0, 0),
+        end_time=datetime.time(23, 0, 0),
+        segment=time_only_segment)
+
+    response = client.get('/')
+    assert response.status_code == 200
+
+    assert client.session['segments'][0]['encoded_name'] == 'time-only'

tests/unit/test_rules_visitcount.py

@@ -0,0 +1,22 @@
+import pytest
+
+
+@pytest.mark.django_db
+def test_visit_count(site, client):
+    response = client.get('/')
+    assert response.status_code == 200
+    visit_count = client.session['visit_count']
+    assert visit_count[0]['path'] == '/'
+    assert visit_count[0]['count'] == 1
+
+    response = client.get('/')
+    assert response.status_code == 200
+    visit_count = client.session['visit_count']
+    assert visit_count[0]['path'] == '/'
+    assert visit_count[0]['count'] == 2
+
+    response = client.get('/page-1/')
+    assert response.status_code == 200
+    visit_count = client.session['visit_count']
+    assert visit_count[0]['count'] == 2
+    assert visit_count[1]['count'] == 1