def test_cannot_check_review_qa_without_permissions(self):
user_1 = UserFactory.create()
user_2 = UserFactory.create()
content_type = ContentType.objects.get_for_model(Experiment)
permission = Permission.objects.get(content_type=content_type,
codename="can_check_QA_signoff")
user_1.user_permissions.add(permission)
self.assertTrue(user_1.has_perm("experiments.can_check_QA_signoff"))
self.assertFalse(user_2.has_perm("experiments.can_check_QA_signoff"))
experiment = ExperimentFactory.create_with_status(
Experiment.STATUS_REVIEW)
self.request.user = user_2
form = ExperimentReviewForm(request=self.request,
data={"review_qa": True},
instance=experiment)
self.assertTrue(form.is_valid())
experiment = form.save()
self.assertFalse(experiment.review_qa)
self.request.user = user_1
form = ExperimentReviewForm(request=self.request,
data={"review_qa": True},
instance=experiment)
self.assertTrue(form.is_valid())
experiment = form.save()
self.assertTrue(experiment.review_qa)
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.assertIn(experiment, cloned_experiment.related_to.all())
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 setUp(self):
self.experiment = ExperimentFactory.create_with_variants(
name="Greatest Experiment",
slug="greatest-experiment",
firefox_min_version="68.0",
firefox_max_version="69.0",
firefox_channel="Nightly",
proposed_start_date=date(2019, 5, 1),
proposed_enrollment=5,
proposed_duration=10,
)
self.experiment.analysis_owner = UserFactory.create()
self.subscribing_user = UserFactory.create()
self.experiment.subscribers.add(self.subscribing_user)
def test_has_unread_false_when_all_read(self):
user = UserFactory.create()
for i in range(3):
NotificationFactory.create(user=user, read=True)
self.assertFalse(user.notifications.has_unread)
def test_form_required_fields(self):
experiment = NimbusExperiment.objects.create(
owner=UserFactory.create(),
status=NimbusExperiment.Status.DRAFT,
name="name",
slug="slug",
application=NimbusExperiment.Application.DESKTOP,
)
form = NimbusExperimentAdminForm(
instance=experiment,
data={
"owner": experiment.owner,
"status": experiment.status,
"publish_status": experiment.publish_status,
"name": experiment.name,
"slug": experiment.slug,
"proposed_duration": experiment.proposed_duration,
"proposed_enrollment": experiment.proposed_enrollment,
"population_percent": experiment.population_percent,
"total_enrolled_clients": experiment.total_enrolled_clients,
"application": experiment.application,
"hypothesis": experiment.hypothesis,
},
)
self.assertTrue(form.is_valid(), form.errors)
def test_view_creates_experiment(self):
user = UserFactory.create()
user_email = user.email
data = {
"type": Experiment.TYPE_PREF,
"name": "A new experiment!",
"short_description": "Let us learn new things",
"data_science_bugzilla_url": "https://bugzilla.mozilla.org/123/",
"feature_bugzilla_url": "https://bugzilla.mozilla.org/123/",
"related_work": "Designs: https://www.example.com/myproject/",
"proposed_start_date": timezone.now().date(),
"proposed_enrollment": 10,
"proposed_duration": 20,
"owner": user.id,
}
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_get_unread_returns_notifications_for_one_user(self):
user1 = UserFactory.create()
user2 = UserFactory.create()
user1_notifications = []
user2_notifications = []
for i in range(3):
user1_notifications.append(NotificationFactory.create(user=user1))
user2_notifications.append(NotificationFactory.create(user=user2))
self.assertEqual(set(user1.notifications.get_unread()),
set(user1_notifications))
self.assertEqual(set(user1.notifications.get_unread()), set([]))
self.assertEqual(set(user2.notifications.get_unread()),
set(user2_notifications))
self.assertEqual(set(user2.notifications.get_unread()), set([]))
def test_admin_form_renders(self):
user = UserFactory.create(is_staff=True, is_superuser=True)
experiment = NimbusExperimentFactory.create_with_lifecycle(
NimbusExperimentFactory.Lifecycles.ENDING_APPROVE_APPROVE)
response = self.client.get(
reverse(
"admin:experiments_nimbusexperiment_change",
args=(experiment.pk, ),
), **{settings.OPENIDC_EMAIL_HEADER: user.email})
self.assertEqual(response.status_code, 200)
def test_generate_change_log_is_empty_when_no_change(self):
experiment = ExperimentFactory.create()
old_serialized_val = ChangeLogSerializer(experiment).data
new_serialized_val = ChangeLogSerializer(experiment).data
changed_data = {}
user = UserFactory.create()
generate_change_log(old_serialized_val, new_serialized_val, experiment,
changed_data, user)
changed_values = experiment.changes.latest().changed_values
self.assertEqual(changed_values, {})
def test_list_view_filters_and_orders_experiments(self):
user_email = "*****@*****.**"
ordering = "latest_change"
filtered_channel = Experiment.CHANNEL_CHOICES[1][0]
filtered_owner = UserFactory.create()
filtered_status = Experiment.STATUS_DRAFT
filtered_types = (Experiment.TYPE_PREF, Experiment.TYPE_GENERIC)
filtered_version = Experiment.VERSION_CHOICES[1][0]
for i in range(3):
for filtered_type in filtered_types:
ExperimentFactory.create_with_status(
firefox_channel=filtered_channel,
firefox_min_version=filtered_version,
owner=filtered_owner,
target_status=filtered_status,
type=filtered_type,
)
for i in range(3):
ExperimentFactory.create_with_status(
random.choice(Experiment.STATUS_CHOICES)[0])
filtered_ordered_experiments = Experiment.objects.filter(
firefox_channel=filtered_channel,
firefox_min_version=filtered_version,
owner=filtered_owner,
status=filtered_status,
type__in=filtered_types,
).order_by(ordering)
response = self.client.get(
"{url}?{params}".format(
url=reverse("home"),
params=urlencode(
{
"firefox_channel": filtered_channel,
"firefox_version": filtered_version,
"ordering": ordering,
"owner": filtered_owner.id,
"status": filtered_status,
"type": filtered_types,
},
True,
),
),
**{settings.OPENIDC_EMAIL_HEADER: user_email},
)
context = response.context[0]
self.assertEqual(response.status_code, 200)
self.assertEqual(list(context["experiments"]),
list(filtered_ordered_experiments))
def test_formats_str_if_no_message_set(self):
now = timezone.now()
user = UserFactory.create()
changelog = NimbusChangeLogFactory.create(
changed_by=user,
changed_on=now,
old_status=NimbusExperiment.Status.DRAFT,
new_status=NimbusExperiment.Status.PREVIEW,
message=None,
)
self.assertEqual(str(changelog), f"Draft > Preview by {user.email} on {now}")
def test_filters_by_owner(self):
owner = UserFactory.create()
for i in range(3):
ExperimentFactory.create_with_status(Experiment.STATUS_DRAFT,
owner=owner)
ExperimentFactory.create_with_status(Experiment.STATUS_DRAFT)
filter = ExperimentFilterset({"owner": owner.id},
queryset=Experiment.objects.all())
self.assertEqual(set(filter.qs),
set(Experiment.objects.filter(owner=owner)))
def test_send_intent_to_ship_email_with_risk_fields(self):
experiment = ExperimentFactory.create(
name="Experiment",
slug="experiment",
risks="Fictitious risk",
risk_technical_description="Fictitious technical challenge",
population_percent=10.0,
firefox_min_version="56.0",
firefox_max_version="",
firefox_channel="Nightly",
)
sender = "*****@*****.**"
release_drivers = "*****@*****.**"
user = UserFactory.create(email="*****@*****.**")
experiment.subscribers.add(user)
with self.settings(EMAIL_SENDER=sender,
EMAIL_RELEASE_DRIVERS=release_drivers):
send_intent_to_ship_email(experiment.id)
bug_url = settings.BUGZILLA_DETAIL_URL.format(
id=experiment.bugzilla_id)
expected_locales = self.format_locales(experiment)
expected_countries = self.format_countries(experiment)
expected_version_channel = self.format_version_and_channel(experiment)
sent_email = mail.outbox[-1]
self.assertEqual(sent_email.subject,
"Delivery Intent to ship: Experiment 56.0 Nightly")
self.assertEqual(sent_email.from_email, sender)
self.assertEqual(
set(sent_email.recipients()),
set([
release_drivers,
experiment.owner.email,
experiment.analysis_owner,
"*****@*****.**",
]),
)
self.assertTrue(
experiment.emails.filter(
type=ExperimentConstants.INTENT_TO_SHIP_EMAIL_LABEL).exists())
self.assertIn(f"Experimenter Bug: {bug_url}", sent_email.body)
self.assertIn(f"Locales: {expected_locales}; {expected_countries}",
sent_email.body)
self.assertIn(f"Timeline & Channel: {expected_version_channel}",
sent_email.body)
self.assertIn("Fictitious risk", sent_email.body)
self.assertIn("Fictitious technical challenge", sent_email.body)
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)
new_start_date = timezone.now().date() + datetime.timedelta(
days=random.randint(1, 100))
new_enrollment = experiment.proposed_enrollment + 1
new_duration = experiment.proposed_duration + 1
bug_url = "https://bugzilla.mozilla.org/show_bug.cgi?id=123"
data = {
"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/",
"proposed_start_date": new_start_date,
"proposed_enrollment": new_enrollment,
"proposed_duration": new_duration,
"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.proposed_start_date, new_start_date)
self.assertEqual(experiment.proposed_enrollment, new_enrollment)
self.assertEqual(experiment.proposed_duration, new_duration)
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_can_review_false_for_non_review_publish_status(self):
experiment = NimbusExperimentFactory.create_with_lifecycle(
NimbusExperimentFactory.Lifecycles.CREATED, )
experiment.apply_lifecycle_state(
NimbusExperimentFactory.LifecycleStates.DRAFT_REVIEW)
experiment.save()
generate_nimbus_changelog(experiment, experiment.owner, "test message")
experiment.publish_status = NimbusExperiment.PublishStatus.IDLE
experiment.save()
self.assertFalse(experiment.can_review(UserFactory.create()))
def test_can_review_for_requesting_user_if_dev_user_and_setting_enabled(
self, email, is_allowed):
user = UserFactory.create(email=email)
experiment = NimbusExperimentFactory.create_with_lifecycle(
NimbusExperimentFactory.Lifecycles.CREATED,
owner=user,
)
experiment.apply_lifecycle_state(
NimbusExperimentFactory.LifecycleStates.DRAFT_REVIEW)
experiment.save()
generate_nimbus_changelog(experiment, experiment.owner, "test message")
self.assertEqual(experiment.can_review(user), is_allowed)
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)
ds_url = "{base}DS-123".format(base=settings.DS_ISSUE_HOST)
bug_url = "{base}show_bug.cgi?id=123".format(
base=settings.BUGZILLA_HOST)
data = {
"action": "continue",
"type": Experiment.TYPE_PREF,
"name": "A new name!",
"short_description": "A new description!",
"public_name": "Public Name",
"public_description": "Public Description",
"data_science_issue_url": ds_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_can_review_true_for_non_requesting_user(self, last_publish_status):
experiment = NimbusExperimentFactory.create_with_lifecycle(
NimbusExperimentFactory.Lifecycles.CREATED,
)
for publish_status in (
NimbusExperiment.PublishStatus.REVIEW,
NimbusExperiment.PublishStatus.APPROVED,
NimbusExperiment.PublishStatus.WAITING,
):
experiment.publish_status = publish_status
experiment.save()
generate_nimbus_changelog(experiment, experiment.owner, "test message")
if publish_status == last_publish_status:
break
self.assertTrue(experiment.can_review(UserFactory.create()))
def test_send_experiment_change_email(self):
experiment = ExperimentFactory.create(
name="exp1", type=ExperimentConstants.TYPE_PREF)
user = UserFactory.create(email="*****@*****.**")
change = ExperimentChangeLogFactory.create(experiment=experiment,
changed_by=user)
send_experiment_change_email(change)
sent_email = mail.outbox[-1]
expected_subject = (
"[Experimenter]: [email protected] made a change to Pref-Flip Experiment: exp1"
)
self.assertEqual(sent_email.subject, expected_subject)
self.assertEqual(sent_email.content_subtype, "html")
self.assertTrue(
experiment.emails.filter(
type=ExperimentConstants.EXPERIMENT_EDIT).exists())
def test_mixin_creates_change_log_with_request_user_on_save(self):
class TestForm(ChangeLogMixin, forms.ModelForm):
class Meta:
model = Experiment
fields = ("name", "owner", "slug")
user = UserFactory.create()
data = factory.build(dict, FACTORY_CLASS=ExperimentFactory)
data["owner"] = user
form = TestForm(request=self.request, data=data)
self.assertTrue(form.is_valid())
experiment = form.save()
self.assertEqual(experiment.changes.count(), 1)
change = experiment.changes.get()
self.assertEqual(change.changed_by, self.user)
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_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_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_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 setUp(self):
self.user = UserFactory.create()
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 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)
