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)