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'
def test_get_segment_by_id(rf):
request = rf.get('/')
adapter = adapters.SessionSegmentsAdapter(request)
segment_1 = SegmentFactory(name='segment-1', persistent=True)
segment_2 = SegmentFactory(name='segment-2', persistent=True)
adapter.set_segments([segment_1, segment_2])
segment_x = adapter.get_segment_by_id(segment_2.pk)
assert segment_x == segment_2
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_get_segments(rf):
request = rf.get('/')
adapter = adapters.SessionSegmentsAdapter(request)
segment_1 = SegmentFactory(name='segment-1', persistent=True)
segment_2 = SegmentFactory(name='segment-2', persistent=True)
adapter.set_segments([segment_1, segment_2])
assert len(request.session['segments']) == 2
segments = adapter.get_segments()
assert segments == [segment_1, segment_2]
def test_update_visit_count_deleted_segment(rf, site):
request = rf.get('/')
adapter = adapters.SessionSegmentsAdapter(request)
segment_1 = SegmentFactory(name='segment-1',
persistent=True,
visit_count=0)
segment_2 = SegmentFactory(name='segment-2',
persistent=True,
visit_count=0)
adapter.set_segments([segment_1, segment_2])
segment_2.delete()
adapter.update_visit_count()
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
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
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'
def test_page_listing_more_buttons(site, rf, segmented_page):
page = segmented_page.personalisation_metadata.canonical_page
SegmentFactory(name='something')
result = wagtail_hooks.page_listing_more_buttons(page, [])
items = list(result)
assert len(items) == 3
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_session_not_added_to_static_segment_after_full(
site, client, django_user_model):
user = django_user_model.objects.create(username='******')
other_user = django_user_model.objects.create(username='******')
segment = SegmentFactory.build(type=Segment.TYPE_STATIC, count=1)
rule = VisitCountRule(counted_page=site.root_page)
form = form_with_data(segment, rule)
instance = form.save()
assert not instance.static_users.all()
session = client.session
client.force_login(user)
client.get(site.root_page.url)
assert instance.static_users.count() == 1
client.cookies.clear()
second_session = client.session
client.force_login(other_user)
client.get(site.root_page.url)
assert session.session_key != second_session.session_key
assert instance.static_users.count() == 1
assert user in instance.static_users.all()
assert other_user not in instance.static_users.all()
def test_segment_edit_view(site, client, django_user_model):
test_segment = SegmentFactory()
try:
new_panel = test_segment.panels[1].children[0].bind_to(model=Segment)
except AttributeError:
new_panel = test_segment.panels[1].children[0].bind_to_model(Segment)
assert new_panel.related.name == "wagtail_personalisation_timerules"
def test_segment_template_block(rf, site):
SegmentFactory(name='test', persistent=True)
request = rf.get('/')
request.session['segments'] = [{
"encoded_name": 'test',
"id": 1,
"timestamp": int(time.time()),
"persistent": True
}]
content = render_template("""
{% load wagtail_personalisation_tags %}
{% segment name='test' %}Test{% endsegment %}
""",
request=request).strip()
assert content == "Test"
content = render_template("""
{% load wagtail_personalisation_tags %}
{% segment name='test2' %}Test{% endsegment %}
""",
request=request).strip()
assert content == ""
with pytest.raises(TemplateSyntaxError):
content = render_template("""
{% load wagtail_personalisation_tags %}
{% segment wrongname='test2' %}Test{% endsegment %}
""",
request=request).strip()
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'
def test_create_segment_with_time_rule():
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)
def test_test_user_calls_get_country(rf):
segment = SegmentFactory(name='Test segment')
rule = OriginCountryRuleFactory(segment=segment, country='GB')
request = rf.get('/')
with patch.object(rule, 'get_country') as get_country_mock:
rule.test_user(request)
get_country_mock.assert_called_once_with(request)
def test_visit_count_rule(self, client):
segment = SegmentFactory(name='Visit Count')
VisitCountRuleFactory(counted_page=self.site.root_page,
segment=segment)
client.get("/root")
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_query_rule_create():
segment = SegmentFactory(name='Query')
query_rule = QueryRuleFactory(parameter="query",
value="value",
segment=segment)
assert query_rule.parameter == 'query'
assert query_rule.value == 'value'
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'
def test_dynamic_segment_with_non_static_rules_have_a_count():
segment = SegmentFactory.build(type=Segment.TYPE_DYNAMIC, count=0)
rule = TimeRule(
start_time=datetime.time(0, 0, 0),
end_time=datetime.time(23, 59, 59),
)
form = form_with_data(segment, rule)
assert form.is_valid(), form.errors
def test_randomisation_percentage_max_100(site, client, mocker,
django_user_model):
segment = SegmentFactory.build(type=Segment.TYPE_STATIC)
segment.randomisation_percent = 101
rule = VisitCountRule()
form = form_with_data(segment, rule)
assert not form.is_valid()
def test_user_added_to_static_segment_at_creation(site, user, mocker):
segment = SegmentFactory.build(type=Segment.TYPE_STATIC)
rule = VisitCountRule(counted_page=site.root_page)
form = form_with_data(segment, rule)
mocker.patch('wagtail_personalisation.rules.VisitCountRule.test_user',
return_value=True)
instance = form.save()
assert user in instance.static_users.all()
def test_non_static_rules_have_a_count():
segment = SegmentFactory.build(type=Segment.TYPE_STATIC, count=0)
rule = TimeRule(
start_time=datetime.time(0, 0, 0),
end_time=datetime.time(23, 59, 59),
segment=segment,
)
form = form_with_data(segment, rule)
assert not form.is_valid()
def test_create_segment_factory():
factoried_segment = SegmentFactory()
segment = Segment(name='TestSegment', status='enabled')
TimeRule(start_time=datetime.time(8, 0, 0),
end_time=datetime.time(23, 0, 0),
segment=segment)
assert factoried_segment.name == segment.name
assert factoried_segment.status == segment.status
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'
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']
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'
def test_randomisation_percentage_added_to_segment_at_creation(
site, client, mocker, django_user_model):
segment = SegmentFactory.build(type=Segment.TYPE_STATIC)
segment.randomisation_percent = 80
rule = VisitCountRule()
form = form_with_data(segment, rule)
instance = form.save()
assert instance.randomisation_percent == 80
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