def test_get_detail_returns_data_for_rapid_experiment(self):
user_email = "*****@*****.**"
owner = UserFactory(email=user_email)
experiment = ExperimentRapidFactory.create_with_status(
Experiment.STATUS_DRAFT,
owner=owner,
)
response = self.client.get(
reverse("experiments-rapid-detail",
kwargs={"slug": experiment.slug}),
**{settings.OPENIDC_EMAIL_HEADER: user_email},
)
self.assertEqual(response.status_code, 200)
json_data = json.loads(response.content)
serialized_experiment = ExperimentRapidSerializer(experiment).data
self.assertDictEqual(serialized_experiment, json_data)
def test_outputs_expected_schema_for_empty_experiment(self):
owner = UserFactory.create()
experiment = NimbusExperiment.objects.create(owner=owner)
data = dict(NimbusExperimentChangeLogSerializer(experiment).data)
self.assertEqual(
data,
{
"application": "",
"branches": [],
"channel": NimbusExperiment.Channel.NO_CHANNEL,
"countries": [],
"feature_config": None,
"firefox_min_version": NimbusExperiment.Version.NO_VERSION,
"hypothesis": NimbusExperiment.HYPOTHESIS_DEFAULT,
"is_paused": False,
"locales": [],
"name": "",
"owner": owner.email,
"population_percent": "0.0000",
"primary_outcomes": [],
"projects": [],
"proposed_duration":
NimbusExperiment.DEFAULT_PROPOSED_DURATION,
"proposed_enrollment":
NimbusExperiment.DEFAULT_PROPOSED_ENROLLMENT,
"public_description": "",
"publish_status": NimbusExperiment.PublishStatus.IDLE.value,
"published_dto": None,
"results_data": None,
"reference_branch": None,
"risk_brand": None,
"risk_mitigation_link": "",
"risk_partner_related": None,
"risk_revenue": None,
"secondary_outcomes": [],
"slug": "",
"status": NimbusExperiment.Status.DRAFT.value,
"status_next": None,
"targeting_config_slug":
NimbusExperiment.TargetingConfig.NO_TARGETING,
"total_enrolled_clients": 0,
},
)
def test_view_flips_subscribed_bool_and_redirects(self):
user = UserFactory()
experiment = ExperimentFactory.create()
self.assertFalse(user in experiment.subscribers.all())
response = self.client.post(
reverse("experiments-subscribed-update",
kwargs={"slug": experiment.slug}),
**{settings.OPENIDC_EMAIL_HEADER: user.email},
)
self.assertRedirects(
response,
reverse("experiments-detail", kwargs={"slug": experiment.slug}),
fetch_redirect_response=False,
)
experiment = Experiment.objects.get(id=experiment.id)
self.assertTrue(user in experiment.subscribers.all())
def test_view_creates_experiment(self):
user = UserFactory.create()
user_email = user.email
ds_issue_url = "https://jira.example.com/browse/DS-123"
bugzilla_url = "https://bugzilla.example.com/show_bug.cgi?id=123"
data = {
"action": "continue",
"type": Experiment.TYPE_PREF,
"name": "A new experiment!",
"short_description": "Let us learn new things",
"public_name": "Public Name",
"public_description": "Public Description",
"data_science_issue_url": ds_issue_url,
"feature_bugzilla_url": bugzilla_url,
"related_work": "Designs: https://www.example.com/myproject/",
"owner": user.id,
"analysis_owner": user.id,
}
with self.settings(
BUGZILLA_HOST="https://bugzilla.example.com",
DS_ISSUE_HOST="https://jira.example.com/browse/",
):
response = self.client.post(
reverse("experiments-create"),
data,
**{settings.OPENIDC_EMAIL_HEADER: user_email},
)
self.assertEqual(response.status_code, 302)
experiment = Experiment.objects.get()
self.assertEqual(experiment.status, experiment.STATUS_DRAFT)
self.assertEqual(experiment.name, data["name"])
self.assertEqual(experiment.changes.count(), 1)
change = experiment.changes.get()
self.assertEqual(change.changed_by, user)
self.assertEqual(change.old_status, None)
self.assertEqual(change.new_status, experiment.STATUS_DRAFT)
def test_returns_200(self):
user = UserFactory()
user.is_staff = True
user.is_superuser = True
user.save()
experiment = ExperimentFactory.create_with_status(
ExperimentFactory.STATUS_DRAFT)
response = self.client.get(
reverse("admin:experiments_experiment_change",
kwargs={"object_id": experiment.id}),
**{settings.OPENIDC_EMAIL_HEADER: user.email},
)
self.assertEqual(response.status_code, 200)
def test_returns_200(self):
user = UserFactory()
user.is_staff = True
user.is_superuser = True
user.save()
reportLog = ReportLogFactory.create()
response = self.client.get(
reverse(
"admin:reporting_reportlog_change", kwargs={"object_id": reportLog.id}
),
**{settings.OPENIDC_EMAIL_HEADER: user.email},
)
self.assertEqual(response.status_code, 200)
def test_view_saves_experiment(self):
user = UserFactory.create()
user_email = user.email
experiment = ExperimentFactory.create_with_status(
Experiment.STATUS_DRAFT,
proposed_enrollment=1,
proposed_duration=2)
bug_url = "https://bugzilla.mozilla.org/show_bug.cgi?id=123"
data = {
"action": "continue",
"type": Experiment.TYPE_PREF,
"name": "A new name!",
"short_description": "A new description!",
"data_science_bugzilla_url": bug_url,
"feature_bugzilla_url": bug_url,
"related_work": "Designs: https://www.example.com/myproject/",
"owner": user.id,
"analysis_owner": user.id,
}
response = self.client.post(
reverse("experiments-overview-update",
kwargs={"slug": experiment.slug}),
data,
**{settings.OPENIDC_EMAIL_HEADER: user_email},
)
self.assertEqual(response.status_code, 302)
experiment = Experiment.objects.get()
self.assertEqual(experiment.name, data["name"])
self.assertEqual(experiment.short_description,
data["short_description"])
self.assertEqual(experiment.analysis_owner, user)
self.assertEqual(experiment.changes.count(), 2)
change = experiment.changes.latest()
self.assertEqual(change.changed_by, user)
self.assertEqual(change.old_status, experiment.STATUS_DRAFT)
self.assertEqual(change.new_status, experiment.STATUS_DRAFT)
def test_serializer_creates_changelog_for_updates(self):
owner = UserFactory(email="*****@*****.**")
experiment = ExperimentFactory.create_with_status(
target_status=Experiment.STATUS_DRAFT,
type=Experiment.TYPE_RAPID,
rapid_type=Experiment.RAPID_AA_CFR,
owner=owner,
name="rapid experiment",
slug="rapid-experiment",
objectives="gotta go fast",
public_description=Experiment.BUGZILLA_RAPID_EXPERIMENT_TEMPLATE,
)
self.assertEqual(experiment.changes.count(), 1)
data = {
"name": "changing the name",
"objectives": "changing objectives",
}
serializer = ExperimentRapidSerializer(
instance=experiment, data=data, context={"request": self.request})
self.assertTrue(serializer.is_valid())
experiment = serializer.save()
self.assertEqual(experiment.changes.count(), 2)
changed_values = {
"name": {
"new_value": "changing the name",
"old_value": "rapid experiment",
"display_name": "Name",
},
"objectives": {
"new_value": "changing objectives",
"old_value": "gotta go fast",
"display_name": "Objectives",
},
}
self.assertTrue(
experiment.changes.filter(
old_status=Experiment.STATUS_DRAFT,
new_status=Experiment.STATUS_DRAFT,
changed_values=changed_values,
).exists())
def test_get_unread_returns_unread_and_marks_as_read(self):
user = UserFactory.create()
unread_notifications = []
for i in range(3):
unread_notifications.append(
NotificationFactory.create(user=user, read=False))
read_notifications = []
for i in range(3):
read_notifications.append(
NotificationFactory.create(user=user, read=True))
self.assertTrue(user.notifications.has_unread)
notifications = user.notifications.get_unread()
self.assertFalse(user.notifications.has_unread)
self.assertEqual(set(notifications), set(unread_notifications))
def test_serializer_rejects_too_many_primary_probe_sets(self):
user = UserFactory()
experiment = NimbusExperimentFactory(probe_sets=[])
probe_sets = [NimbusProbeSetFactory() for i in range(3)]
serializer = NimbusProbeSetUpdateSerializer(
experiment,
{
"primary_probe_sets": [p.id for p in probe_sets],
"secondary_probe_sets": [],
},
context={"user": user},
)
self.assertEqual(experiment.changes.count(), 0)
self.assertFalse(serializer.is_valid())
self.assertEqual(experiment.changes.count(), 0)
self.assertIn(
"Exceeded maximum primary probe set limit of",
serializer.errors["primary_probe_sets"][0],
)
def test_latest_review_request_returns_most_recent_review_request(self):
reviewer = UserFactory()
experiment = NimbusExperimentFactory.create_with_lifecycle(
NimbusExperimentFactory.Lifecycles.CREATED,
)
experiment.publish_status = NimbusExperiment.PublishStatus.REVIEW
experiment.save()
generate_nimbus_changelog(experiment, experiment.owner, "test message")
experiment.publish_status = NimbusExperiment.PublishStatus.IDLE
experiment.save()
generate_nimbus_changelog(experiment, reviewer, "test message")
experiment.publish_status = NimbusExperiment.PublishStatus.REVIEW
experiment.save()
second_request = generate_nimbus_changelog(
experiment, experiment.owner, "test message"
)
self.assertEqual(experiment.changes.latest_review_request(), second_request)
def test_get_detail_returns_data_for_rapid_experiment(self):
user_email = "*****@*****.**"
owner = UserFactory(email=user_email)
experiment = ExperimentFactory.create(
type=Experiment.TYPE_RAPID,
owner=owner,
name="rapid experiment",
objectives="gotta go fast",
)
response = self.client.get(
reverse("experiments-rapid-detail",
kwargs={"slug": experiment.slug}),
**{settings.OPENIDC_EMAIL_HEADER: user_email},
)
self.assertEqual(response.status_code, 200)
json_data = json.loads(response.content)
serialized_experiment = ExperimentRapidSerializer(experiment).data
self.assertDictEqual(serialized_experiment, json_data)
def test_view_creates_experiment(self):
user = UserFactory.create()
user_email = user.email
bug_url = "https://bugzilla.mozilla.org/show_bug.cgi?id=123"
data = {
"type": Experiment.TYPE_PREF,
"name": "A new experiment!",
"short_description": "Let us learn new things",
"data_science_bugzilla_url": bug_url,
"feature_bugzilla_url": bug_url,
"related_work": "Designs: https://www.example.com/myproject/",
"proposed_start_date": timezone.now().date(),
"proposed_enrollment": 10,
"proposed_duration": 20,
"owner": user.id,
}
with self.settings(BUGZILLA_HOST="https://bugzilla.mozilla.org"):
response = self.client.post(
reverse("experiments-create"),
data,
**{settings.OPENIDC_EMAIL_HEADER: user_email},
)
self.assertEqual(response.status_code, 302)
experiment = Experiment.objects.get()
self.assertEqual(experiment.status, experiment.STATUS_DRAFT)
self.assertEqual(experiment.name, data["name"])
self.assertEqual(experiment.changes.count(), 1)
change = experiment.changes.get()
self.assertEqual(change.changed_by, user)
self.assertEqual(change.old_status, None)
self.assertEqual(change.new_status, experiment.STATUS_DRAFT)
def test_serializer_updates_audience_on_experiment_invalid_channels(self):
user = UserFactory()
experiment = NimbusExperimentFactory(
channel=None,
application=NimbusExperiment.Application.FENIX,
firefox_min_version=None,
population_percent=0.0,
proposed_duration=None,
proposed_enrollment=None,
targeting_config_slug=None,
total_enrolled_clients=0,
)
serializer = NimbusAudienceUpdateSerializer(
experiment,
{
"channel":
NimbusConstants.Channel.DESKTOP_BETA.value,
"firefox_min_version":
NimbusConstants.Version.FIREFOX_80.value,
"population_percent":
10,
"proposed_duration":
42,
"proposed_enrollment":
120,
"targeting_config_slug":
(NimbusConstants.TargetingConfig.ALL_ENGLISH.value),
"total_enrolled_clients":
100,
},
context={"user": user},
)
self.assertEqual(experiment.changes.count(), 0)
self.assertFalse(serializer.is_valid())
self.assertEqual(
serializer.errors,
{"channel": ["Invalid channel for experiment application."]},
)
def test_serializer_rejects_duplicate_probes(self):
user = UserFactory()
experiment = NimbusExperimentFactory(probe_sets=[])
probe_sets = [NimbusProbeSetFactory() for i in range(3)]
serializer = NimbusProbeSetUpdateSerializer(
experiment,
{
"primary_probe_sets": [
p.id for p in
probe_sets[:NimbusExperiment.MAX_PRIMARY_PROBE_SETS]
],
"secondary_probe_sets": [p.id for p in probe_sets],
},
context={"user": user},
)
self.assertEqual(experiment.changes.count(), 0)
self.assertFalse(serializer.is_valid())
self.assertEqual(experiment.changes.count(), 0)
self.assertEqual(
serializer.errors["primary_probe_sets"][0],
"Primary probe sets cannot overlap with secondary probe sets.",
)
def test_view_filters_by_subscriber(self):
user = UserFactory(email="*****@*****.**")
experiment1 = ExperimentFactory.create_with_status(
Experiment.STATUS_DRAFT, name="a")
experiment1.subscribers.add(user)
experiment2 = ExperimentFactory.create_with_status(
Experiment.STATUS_DRAFT, name="b")
experiment2.subscribers.add(user)
ExperimentFactory.create_with_variants()
url = reverse("experiments-api-csv")
response = self.client.get(
f"{url}?subscribed=on",
**{settings.OPENIDC_EMAIL_HEADER: user.email})
self.assertEqual(response.status_code, 200)
csv_data = response.content
expected_csv_data = ExperimentCSVRenderer().render(
ExperimentCSVSerializer([experiment1, experiment2],
many=True).data,
renderer_context={"header": ExperimentCSVSerializer.Meta.fields},
)
self.assertEqual(csv_data, expected_csv_data)
def test_ordered_changes_orders_by_date(self):
experiment = ExperimentFactory.create()
date1 = datetime.datetime.now() - datetime.timedelta(days=2)
date2 = datetime.datetime.now() - datetime.timedelta(days=1)
date3 = datetime.datetime.now()
user1 = UserFactory.create()
user2 = UserFactory.create()
user3 = UserFactory.create()
ExperimentChangeLogFactory.create(
experiment=experiment,
changed_by=user1,
changed_on=date1,
message="a",
)
ExperimentChangeLogFactory.create(
experiment=experiment,
changed_by=user1,
changed_on=date1,
message="b",
)
ExperimentChangeLogFactory.create(
experiment=experiment,
changed_by=user1,
changed_on=date1,
message="b",
)
ExperimentChangeLogFactory.create(
experiment=experiment,
changed_by=user2,
changed_on=date1,
message="c",
)
ExperimentChangeLogFactory.create(
experiment=experiment,
changed_by=user2,
changed_on=date2,
message="d",
)
ExperimentChangeLogFactory.create(
experiment=experiment,
changed_by=user3,
changed_on=date2,
message="e",
)
ExperimentChangeLogFactory.create(
experiment=experiment,
changed_by=user3,
changed_on=date2,
message="f",
)
ExperimentChangeLogFactory.create(
experiment=experiment,
changed_by=user1,
changed_on=date3,
message="g",
)
ExperimentChangeLogFactory.create(
experiment=experiment,
changed_by=user1,
changed_on=date3,
message="h",
)
ExperimentChangeLogFactory.create(
experiment=experiment,
changed_by=user2,
changed_on=date3,
message="i",
)
ExperimentChangeLogFactory.create(
experiment=experiment,
changed_by=user3,
changed_on=date3,
message="j",
)
expected_changes = {
date1.date(): {
user1: set(["a", "b"]),
user2: set(["c"])
},
date2.date(): {
user2: set(["d"]),
user3: set(["e", "f"])
},
date3.date(): {
user1: set(["g", "h"]),
user2: set(["i"]),
user3: set(["j"]),
},
}
ordered_dates = [date for date, changes in experiment.ordered_changes]
self.assertEqual(
ordered_dates,
[date3.date(), date2.date(),
date1.date()])
day3_users = [
user for user, user_changes in experiment.ordered_changes[0][1]
]
self.assertEqual(set(day3_users), set([user1, user2, user3]))
day2_users = [
user for user, user_changes in experiment.ordered_changes[1][1]
]
self.assertEqual(set(day2_users), set([user2, user3]))
day1_users = [
user for user, user_changes in experiment.ordered_changes[2][1]
]
self.assertEqual(set(day1_users), set([user1, user2]))
for date, date_changes in experiment.ordered_changes:
for user, user_changes in date_changes:
self.assertEqual(user_changes, expected_changes[date][user])
def test_grouped_changes_groups_by_date_then_user(self):
experiment = ExperimentFactory.create()
date1 = datetime.datetime.now() - datetime.timedelta(days=2)
date2 = datetime.datetime.now() - datetime.timedelta(days=1)
date3 = datetime.datetime.now()
user1 = UserFactory.create()
user2 = UserFactory.create()
user3 = UserFactory.create()
change1 = ExperimentChangeLogFactory.create(experiment=experiment,
changed_by=user1,
changed_on=date1)
change2 = ExperimentChangeLogFactory.create(experiment=experiment,
changed_by=user1,
changed_on=date1)
change3 = ExperimentChangeLogFactory.create(experiment=experiment,
changed_by=user1,
changed_on=date1)
change4 = ExperimentChangeLogFactory.create(experiment=experiment,
changed_by=user2,
changed_on=date1)
change5 = ExperimentChangeLogFactory.create(experiment=experiment,
changed_by=user2,
changed_on=date2)
change6 = ExperimentChangeLogFactory.create(experiment=experiment,
changed_by=user3,
changed_on=date2)
change7 = ExperimentChangeLogFactory.create(experiment=experiment,
changed_by=user3,
changed_on=date2)
change8 = ExperimentChangeLogFactory.create(experiment=experiment,
changed_by=user1,
changed_on=date3)
change9 = ExperimentChangeLogFactory.create(experiment=experiment,
changed_by=user1,
changed_on=date3)
change10 = ExperimentChangeLogFactory.create(experiment=experiment,
changed_by=user2,
changed_on=date3)
change11 = ExperimentChangeLogFactory.create(experiment=experiment,
changed_by=user3,
changed_on=date3)
self.assertEqual(
set(experiment.grouped_changes.keys()),
set([date1.date(), date2.date(),
date3.date()]),
)
self.assertEqual(
set(experiment.grouped_changes[date1.date()].keys()),
set([user1, user2]),
)
self.assertEqual(
set(experiment.grouped_changes[date2.date()].keys()),
set([user2, user3]),
)
self.assertEqual(
set(experiment.grouped_changes[date3.date()].keys()),
set([user1, user2, user3]),
)
self.assertEqual(
experiment.grouped_changes[date1.date()][user1],
set([change1, change2, change3]),
)
self.assertEqual(experiment.grouped_changes[date1.date()][user2],
set([change4]))
self.assertEqual(experiment.grouped_changes[date2.date()][user2],
set([change5]))
self.assertEqual(
experiment.grouped_changes[date2.date()][user3],
set([change6, change7]),
)
self.assertEqual(
experiment.grouped_changes[date3.date()][user1],
set([change8, change9]),
)
self.assertEqual(experiment.grouped_changes[date3.date()][user2],
set([change10]))
self.assertEqual(experiment.grouped_changes[date3.date()][user3],
set([change11]))
def test_generate_change_log_gives_correct_output(self):
experiment = ExperimentFactory.create_with_status(
target_status=Experiment.STATUS_REVIEW,
num_variants=0,
short_description="description",
qa_status="pretty good",
firefox_min_version="55.0",
)
variant1 = ExperimentVariantFactory.create(
experiment=experiment,
ratio=75,
description="variant1 description",
name="variant1",
slug="variant1-slug",
)
variant1.save()
old_serialized_val = ChangeLogSerializer(experiment).data
experiment.short_description = "changing the description"
experiment.qa_status = "good"
experiment.firefox_min_version = "56.0"
variant2 = ExperimentVariantFactory.create(
experiment=experiment,
ratio=25,
description="variant2 description",
name="variant2",
slug="variant2-slug",
)
variant2.save()
VariantPreferencesFactory.create(
variant=variant2,
pref_name="p1",
pref_type=Experiment.PREF_TYPE_INT,
pref_branch=Experiment.PREF_BRANCH_DEFAULT,
pref_value="5",
)
experiment.save()
new_serialized_val = ChangeLogSerializer(experiment).data
changed_variant_pref = {
"pref_name": "p1",
"pref_type": "integer",
"pref_branch": "default",
"pref_value": "5",
}
changed_data = {
"short_description": "changing the description",
"qa_status": "good",
"firefox_min_version": "56.0",
"variants": [
{
"ratio": 25,
"description": "variant2 description",
"name": "variant2",
"slug": "variant2-slug",
"preferences": [changed_variant_pref],
}
],
}
user = UserFactory.create()
generate_change_log(
old_serialized_val, new_serialized_val, experiment, changed_data, user
)
changed_value = experiment.changes.latest().changed_values
expected_changed_value = {
"firefox_min_version": {
"display_name": "Firefox Min Version",
"new_value": "56.0",
"old_value": "55.0",
},
"qa_status": {
"display_name": "Qa Status",
"new_value": "good",
"old_value": "pretty good",
},
"short_description": {
"display_name": "Short Description",
"new_value": "changing the description",
"old_value": "description",
},
"variants": {
"display_name": "Branches",
"new_value": [
{
"ratio": 25,
"description": "variant2 description",
"name": "variant2",
"slug": "variant2-slug",
},
{
"ratio": 75,
"description": "variant1 description",
"name": "variant1",
"slug": "variant1-slug",
},
],
"old_value": [
{
"ratio": 75,
"description": "variant1 description",
"name": "variant1",
"slug": "variant1-slug",
}
],
},
}
self.assertEqual(
expected_changed_value["firefox_min_version"],
changed_value["firefox_min_version"],
)
self.assertEqual(expected_changed_value["qa_status"], changed_value["qa_status"])
self.assertEqual(
expected_changed_value["short_description"],
changed_value["short_description"],
)
self.assertCountEqual(
expected_changed_value["variants"], changed_value["variants"]
)
def test_filters_by_analysis_owner(self):
user = UserFactory.create()
experiment = ExperimentFactory.create(analysis_owner=user)
filter = ExperimentFilterset(data={"analysis_owner": user.id})
self.assertEqual(set(filter.qs), set([experiment]))
def setUp(self):
self.user = UserFactory.create()
def test_filter_by_analysis_owner_invalid_for_non_analysis_owner(self):
user = UserFactory.create()
filter = ExperimentFilterset(data={"analysis_owner": user.id})
self.assertFalse(filter.is_valid())
def test_clone(self):
user_1 = UserFactory.create()
user_2 = UserFactory.create()
experiment = ExperimentFactory.create_with_variants(
name="great experiment",
status=Experiment.STATUS_COMPLETE,
short_description="This is going to be a great experiment.",
proposed_start_date=datetime.date(2019, 4, 1),
related_work="See also this other experiment.",
proposed_enrollment=2,
proposed_duration=30,
owner=user_1,
bugzilla_id="4455667",
pref_type=Experiment.TYPE_ADDON,
data_science_bugzilla_url="https://bugzilla.mozilla.org/123/",
feature_bugzilla_url="https://bugzilla.mozilla.org/123/",
addon_experiment_id="addon-id",
addon_release_url="addon-url",
archived=True,
review_science=True,
review_ux=True,
firefox_min_version=Experiment.VERSION_CHOICES[1][0],
firefox_max_version="",
)
experiment.clone("best experiment", user_2)
cloned_experiment = Experiment.objects.filter(
name="best experiment").get()
self.assertTrue(cloned_experiment.parent, experiment.id)
self.assertEqual(cloned_experiment.status, Experiment.STATUS_DRAFT)
self.assertEqual(
cloned_experiment.short_description,
"This is going to be a great experiment.",
)
self.assertEqual(cloned_experiment.related_work,
"See also this other experiment.")
self.assertEqual(cloned_experiment.proposed_enrollment, 2)
self.assertEqual(cloned_experiment.proposed_duration, 30)
self.assertEqual(cloned_experiment.pref_type, Experiment.TYPE_ADDON)
self.assertEqual(cloned_experiment.proposed_start_date, None)
self.assertEqual(cloned_experiment.owner, user_2)
self.assertEqual(
cloned_experiment.firefox_min_version,
Experiment.VERSION_CHOICES[1][0],
)
self.assertFalse(cloned_experiment.bugzilla_id)
self.assertFalse(cloned_experiment.archived)
self.assertFalse(cloned_experiment.review_science)
self.assertFalse(cloned_experiment.review_ux)
self.assertFalse(cloned_experiment.addon_experiment_id)
self.assertFalse(cloned_experiment.addon_release_url)
self.assertEqual(cloned_experiment.changes.count(), 1)
change = cloned_experiment.changes.latest()
self.assertEqual(change.old_status, None)
self.assertEqual(change.new_status, experiment.STATUS_DRAFT)
def test_get_owner_display_value_returns_user_str(self):
user = UserFactory.create()
form = ExperimentFiltersetForm({"owner": user.id})
self.assertEqual(form.get_owner_display_value(), str(user))
def test_form_saves_reviews(self):
user = UserFactory.create()
content_type = ContentType.objects.get_for_model(Experiment)
experiment_model_permissions = Permission.objects.filter(
content_type=content_type, codename__startswith="can_check")
for permission in experiment_model_permissions:
user.user_permissions.add(permission)
self.request.user = user
experiment = ExperimentFactory.create_with_status(
Experiment.STATUS_REVIEW)
self.assertEqual(experiment.changes.count(), 2)
self.assertFalse(experiment.review_science)
self.assertFalse(experiment.review_engineering)
self.assertFalse(experiment.review_qa_requested)
self.assertFalse(experiment.review_intent_to_ship)
self.assertFalse(experiment.review_bugzilla)
self.assertFalse(experiment.review_qa)
self.assertFalse(experiment.review_relman)
self.assertFalse(experiment.review_advisory)
self.assertFalse(experiment.review_legal)
self.assertFalse(experiment.review_ux)
self.assertFalse(experiment.review_security)
self.assertFalse(experiment.review_vp)
self.assertFalse(experiment.review_data_steward)
self.assertFalse(experiment.review_comms)
self.assertFalse(experiment.review_impacted_teams)
data = {
"review_science": True,
"review_engineering": True,
"review_qa_requested": True,
"review_intent_to_ship": True,
"review_bugzilla": True,
"review_qa": True,
"review_relman": True,
"review_advisory": True,
"review_legal": True,
"review_ux": True,
"review_security": True,
"review_vp": True,
"review_data_steward": True,
"review_comms": True,
"review_impacted_teams": True,
}
form = ExperimentReviewForm(request=self.request,
data=data,
instance=experiment)
self.assertTrue(form.is_valid())
experiment = form.save()
self.assertTrue(experiment.review_science)
self.assertTrue(experiment.review_engineering)
self.assertTrue(experiment.review_qa_requested)
self.assertTrue(experiment.review_intent_to_ship)
self.assertTrue(experiment.review_bugzilla)
self.assertTrue(experiment.review_qa)
self.assertTrue(experiment.review_relman)
self.assertTrue(experiment.review_advisory)
self.assertTrue(experiment.review_legal)
self.assertTrue(experiment.review_ux)
self.assertTrue(experiment.review_security)
self.assertTrue(experiment.review_vp)
self.assertTrue(experiment.review_data_steward)
self.assertTrue(experiment.review_comms)
self.assertTrue(experiment.review_impacted_teams)
self.assertEqual(experiment.changes.count(), 3)
def test_post_detail_edits_rapid_experiment(self):
user_email = "*****@*****.**"
audience = "us_only"
features = ["picture_in_picture", "pinned_tabs"]
owner = UserFactory(email=user_email)
experiment = ExperimentRapidFactory.create_with_status(
Experiment.STATUS_DRAFT,
owner=owner,
name="rapid experiment",
slug="rapid-experiment",
objectives="gotta go fast",
audience=audience,
features=features,
firefox_min_version="79.0",
firefox_channel=Experiment.CHANNEL_NIGHTLY,
)
control_variant = experiment.variants.get(is_control=True)
treatment_variant = experiment.variants.get(is_control=False)
data = json.dumps({
"name":
"new name",
"objectives":
"new hypothesis",
"audience":
audience,
"features":
features,
"firefox_min_version":
"80.0",
"firefox_channel":
Experiment.CHANNEL_RELEASE,
"variants": [
{
"id": control_variant.id,
"slug": "control",
"name": "control",
"ratio": 50,
"description": "a variant",
"is_control": True,
},
{
"id": treatment_variant.id,
"slug": "variant",
"name": "variant",
"ratio": 50,
"description": "a variant",
"is_control": False,
},
],
})
response = self.client.put(
reverse("experiments-rapid-detail",
kwargs={"slug": experiment.slug}),
data,
content_type="application/json",
**{settings.OPENIDC_EMAIL_HEADER: user_email},
)
self.assertEqual(response.status_code, 200)
experiment = Experiment.objects.get()
self.assertEqual(experiment.owner.email, user_email)
self.assertEqual(experiment.name, "new name")
self.assertEqual(experiment.slug, "rapid-experiment")
self.assertEqual(experiment.objectives, "new hypothesis")
self.assertEqual(experiment.audience, audience)
self.assertEqual(experiment.features, features)
self.assertEqual(experiment.firefox_min_version, "80.0")
self.assertEqual(experiment.firefox_channel,
Experiment.CHANNEL_RELEASE)
def test_ordered_changes_orders_by_date(self):
experiment = ExperimentFactory.create()
date1 = timezone.now() - datetime.timedelta(days=2)
date2 = timezone.now() - datetime.timedelta(days=1)
date3 = timezone.now()
user1 = UserFactory.create()
user2 = UserFactory.create()
user3 = UserFactory.create()
a = ExperimentChangeLogFactory.create(
experiment=experiment, changed_by=user1, changed_on=date1, message="a"
)
b = ExperimentChangeLogFactory.create(
experiment=experiment, changed_by=user1, changed_on=date1, message="b"
)
c = ExperimentChangeLogFactory.create(
experiment=experiment, changed_by=user2, changed_on=date1, message="c"
)
d = ExperimentChangeLogFactory.create(
experiment=experiment, changed_by=user2, changed_on=date2, message="d"
)
e = ExperimentChangeLogFactory.create(
experiment=experiment, changed_by=user3, changed_on=date2, message="e"
)
f = ExperimentChangeLogFactory.create(
experiment=experiment, changed_by=user3, changed_on=date2, message="f"
)
g = ExperimentChangeLogFactory.create(
experiment=experiment, changed_by=user1, changed_on=date3, message="g"
)
h = ExperimentChangeLogFactory.create(
experiment=experiment, changed_by=user1, changed_on=date3, message="h"
)
i = ExperimentChangeLogFactory.create(
experiment=experiment, changed_by=user2, changed_on=date3, message="i"
)
j = ExperimentChangeLogFactory.create(
experiment=experiment, changed_by=user3, changed_on=date3, message="j"
)
expected_changes = {
date1.date(): {user1: set([a, b]), user2: set([c])},
date2.date(): {user2: set([d]), user3: set([e, f])},
date3.date(): {user1: set([g, h]), user2: set([i]), user3: set([j])},
}
ordered_dates = [date for date, changes in experiment.ordered_changes]
self.assertEqual(ordered_dates, [date3.date(), date2.date(), date1.date()])
day3_users = [user for user, user_changes in experiment.ordered_changes[0][1]]
self.assertEqual(set(day3_users), set([user1, user2, user3]))
day2_users = [user for user, user_changes in experiment.ordered_changes[1][1]]
self.assertEqual(set(day2_users), set([user2, user3]))
day1_users = [user for user, user_changes in experiment.ordered_changes[2][1]]
self.assertEqual(set(day1_users), set([user1, user2]))
for date, date_changes in experiment.ordered_changes:
for user, user_changes in date_changes:
self.assertEqual(user_changes, expected_changes[date][user])
def test_has_unread_true_when_some_unread(self):
user = UserFactory.create()
NotificationFactory.create(user=user, read=False)
self.assertTrue(user.notifications.has_unread)
def setUp(self):
super().setUp()
self.user = UserFactory()
def setUp(self):
super().setUp()
self.user = UserFactory()
self.request = mock.Mock()
self.request.user = self.user
