def test_sends_emails_for_live_experiments_past_proposed_enrollment_end_date( self, ): experiment1 = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.LAUNCH_APPROVE_APPROVE, proposed_enrollment=10, ) experiment2 = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.ENDING_APPROVE_APPROVE, proposed_enrollment=10, ) experiment3 = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.LAUNCH_APPROVE_APPROVE, proposed_enrollment=10, ) experiment3.changes.filter( old_status=NimbusExperiment.Status.DRAFT, new_status=NimbusExperiment.Status.LIVE, ).update(changed_on=datetime.datetime.now() - datetime.timedelta(days=10)) tasks.nimbus_send_end_enrollment_email() self.assertEqual(experiment1.emails.count(), 0) self.assertEqual(experiment2.emails.count(), 0) self.assertTrue( experiment3.emails.filter( type=NimbusExperiment.EmailType.ENROLLMENT_END ).exists() ) self.assertEqual(experiment3.emails.count(), 1) self.assertEqual(len(mail.outbox), 1)
def test_experiments_by_status(self): user_email = "*****@*****.**" draft_exp = NimbusExperimentFactory.create_with_status( NimbusExperiment.Status.DRAFT) NimbusExperimentFactory.create_with_status( NimbusExperiment.Status.ACCEPTED) response = self.query( """ query { experiments(status: Draft) { name slug publicDescription } } """, headers={settings.OPENIDC_EMAIL_HEADER: user_email}, ) self.assertEqual(response.status_code, 200) content = json.loads(response.content) experiments = content["data"]["experiments"] self.assertEqual(len(experiments), 1) for key in experiments[0]: self.assertEqual(experiments[0][key], str(getattr(draft_exp, to_snake_case(key))))
def test_publishes_preview_experiments_and_unpublishes_non_preview_experiments(self): should_publish_experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.PREVIEW, ) should_unpublish_experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.CREATED, ) self.setup_kinto_get_main_records([should_unpublish_experiment.slug]) tasks.nimbus_synchronize_preview_experiments_in_kinto() data = NimbusExperimentSerializer(should_publish_experiment).data self.mock_kinto_client.create_record.assert_called_with( data=data, collection=settings.KINTO_COLLECTION_NIMBUS_PREVIEW, bucket=settings.KINTO_BUCKET_WORKSPACE, if_not_exists=True, ) self.mock_kinto_client.delete_record.assert_called_with( id=should_unpublish_experiment.slug, collection=settings.KINTO_COLLECTION_NIMBUS_PREVIEW, bucket=settings.KINTO_BUCKET_WORKSPACE, )
def test_experiment_returns_country_and_locale(self): user_email = "*****@*****.**" NimbusExperimentFactory.create(publish_status=NimbusExperiment.PublishStatus.IDLE) response = self.query( """ query { experiments { countries { code name } locales { code name } } } """, headers={settings.OPENIDC_EMAIL_HEADER: user_email}, ) self.assertEqual(response.status_code, 200) content = json.loads(response.content) experiment_data = content["data"]["experiments"][0] for locale in Locale.objects.all(): self.assertIn( {"code": locale.code, "name": locale.name}, experiment_data["locales"] ) for country in Country.objects.all(): self.assertIn( {"code": country.code, "name": country.name}, experiment_data["countries"] )
def test_check_with_no_approved_publish_status_pushes_nothing(self): for lifecycle in [ NimbusExperimentFactory.Lifecycles.CREATED, NimbusExperimentFactory.Lifecycles.LAUNCH_REVIEW_REQUESTED, NimbusExperimentFactory.Lifecycles.LAUNCH_APPROVE_WAITING, NimbusExperimentFactory.Lifecycles.LAUNCH_APPROVE_APPROVE, NimbusExperimentFactory.Lifecycles.PAUSING_REVIEW_REQUESTED, NimbusExperimentFactory.Lifecycles.PAUSING_APPROVE_WAITING, NimbusExperimentFactory.Lifecycles.ENDING_REVIEW_REQUESTED, NimbusExperimentFactory.Lifecycles.ENDING_APPROVE_WAITING, ]: NimbusExperimentFactory.create_with_lifecycle( lifecycle, application=NimbusExperiment.Application.DESKTOP, ) self.setup_kinto_get_main_records([]) self.setup_kinto_no_pending_review() tasks.nimbus_check_kinto_push_queue_by_collection( settings.KINTO_COLLECTION_NIMBUS_DESKTOP ) self.mock_kinto_client.patch_collection.assert_not_called() self.mock_push_task.assert_not_called() self.mock_update_task.assert_not_called() self.mock_end_task.assert_not_called()
def test_only_completes_experiments_with_matching_application_collection( self): desktop_experiment = NimbusExperimentFactory.create_with_status( NimbusExperiment.Status.LIVE, application=NimbusExperiment.Application.DESKTOP, ) fenix_experiment = NimbusExperimentFactory.create_with_status( NimbusExperiment.Status.LIVE, application=NimbusExperiment.Application.FENIX, ) def get_records(bucket, collection): if collection == settings.KINTO_COLLECTION_NIMBUS_DESKTOP: return [{"id": desktop_experiment.slug}] if collection == settings.KINTO_COLLECTION_NIMBUS_MOBILE: return [{"id": fenix_experiment.slug}] self.mock_kinto_client.get_records.side_effect = get_records tasks.nimbus_check_experiments_are_complete() self.assertTrue( NimbusExperiment.objects.filter( id=desktop_experiment.id, status=NimbusExperiment.Status.LIVE).exists()) self.assertTrue( NimbusExperiment.objects.filter( id=fenix_experiment.id, status=NimbusExperiment.Status.LIVE).exists())
def test_experiments_with_no_branches_returns_empty_treatment_values(self): user_email = "*****@*****.**" NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.CREATED, branches=[] ) response = self.query( """ query { experiments { treatmentBranches { name slug description ratio } } } """, headers={settings.OPENIDC_EMAIL_HEADER: user_email}, ) self.assertEqual(response.status_code, 200) content = json.loads(response.content) experiment_data = content["data"]["experiments"][0] self.assertEqual( experiment_data["treatmentBranches"], [{"name": "", "slug": "", "description": "", "ratio": 1}], )
def test_experiment_updates_when_record_is_in_main(self): experiment1 = NimbusExperimentFactory.create_with_status( NimbusExperiment.Status.ACCEPTED, ) experiment2 = NimbusExperimentFactory.create_with_status( NimbusExperiment.Status.ACCEPTED, ) experiment3 = NimbusExperimentFactory.create_with_status( NimbusExperiment.Status.DRAFT, ) self.assertEqual(experiment1.changes.count(), 3) self.assertEqual(experiment2.changes.count(), 3) self.assertEqual(experiment3.changes.count(), 1) self.setup_kinto_get_main_records([experiment1.slug]) tasks.nimbus_check_experiments_are_live() self.assertEqual(experiment3.changes.count(), 1) self.assertTrue( experiment1.changes.filter( changed_by__email=settings.KINTO_DEFAULT_CHANGELOG_USER, old_status=NimbusExperiment.Status.ACCEPTED, new_status=NimbusExperiment.Status.LIVE, ).exists()) self.assertFalse( experiment2.changes.filter( changed_by__email=settings.KINTO_DEFAULT_CHANGELOG_USER, old_status=NimbusExperiment.Status.ACCEPTED, new_status=NimbusExperiment.Status.LIVE, ).exists())
def test_ending_experiment_completed_when_record_is_not_in_main(self): experiment1 = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.LAUNCH_APPROVE_APPROVE, application=NimbusExperiment.Application.DESKTOP, ) experiment2 = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.ENDING_APPROVE_WAITING, application=NimbusExperiment.Application.DESKTOP, ) self.setup_kinto_get_main_records([experiment1.slug]) self.setup_kinto_no_pending_review() tasks.nimbus_check_kinto_push_queue_by_collection( settings.KINTO_COLLECTION_NIMBUS_DESKTOP) self.assertTrue( experiment2.changes.filter( changed_by__email=settings.KINTO_DEFAULT_CHANGELOG_USER, old_status=NimbusExperiment.Status.LIVE, old_publish_status=NimbusExperiment.PublishStatus.WAITING, new_status=NimbusExperiment.Status.COMPLETE, new_publish_status=NimbusExperiment.PublishStatus.IDLE, message=NimbusChangeLog.Messages.COMPLETED, ).exists())
def test_update_queue_returns_experiments_that_should_update_by_application(self): # Should update, correct application experiment_should_update = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.PAUSING_APPROVE, application=NimbusExperiment.Application.DESKTOP, ) # Should update, but wrong application NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.PAUSING_APPROVE, application=NimbusExperiment.Application.FENIX, ) # Shouldn't update, correct application NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.LAUNCH_APPROVE_APPROVE, application=NimbusExperiment.Application.DESKTOP, ) self.assertEqual( list( NimbusExperiment.objects.update_queue( [NimbusExperiment.Application.DESKTOP] ) ), [experiment_should_update], )
def test_experiment_updates_when_record_is_not_in_main(self): experiment1 = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.LAUNCH_APPROVE_APPROVE, ) experiment2 = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.ENDING_APPROVE_WAITING, ) experiment3 = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.CREATED, ) initial_change_count = experiment3.changes.count() self.setup_kinto_get_main_records([experiment1.slug]) tasks.nimbus_check_experiments_are_complete() self.assertEqual(experiment3.changes.count(), initial_change_count) self.assertTrue( NimbusExperiment.objects.filter( id=experiment1.id, status=NimbusExperiment.Status.LIVE, publish_status=NimbusExperiment.PublishStatus.IDLE, ).exists() ) self.assertTrue( NimbusExperiment.objects.filter( id=experiment2.id, status=NimbusExperiment.Status.COMPLETE, publish_status=NimbusExperiment.PublishStatus.IDLE, ).exists() ) self.assertTrue( NimbusExperiment.objects.filter( id=experiment3.id, status=NimbusExperiment.Status.DRAFT, publish_status=NimbusExperiment.PublishStatus.IDLE, ).exists() ) self.assertFalse( experiment1.changes.filter( changed_by__email=settings.KINTO_DEFAULT_CHANGELOG_USER, old_status=NimbusExperiment.Status.LIVE, new_status=NimbusExperiment.Status.COMPLETE, message=NimbusChangeLog.Messages.COMPLETED, ).exists() ) self.assertTrue( experiment2.changes.filter( changed_by__email=settings.KINTO_DEFAULT_CHANGELOG_USER, old_status=NimbusExperiment.Status.LIVE, old_publish_status=NimbusExperiment.PublishStatus.WAITING, new_status=NimbusExperiment.Status.COMPLETE, new_publish_status=NimbusExperiment.PublishStatus.IDLE, message=NimbusChangeLog.Messages.COMPLETED, ).exists() )
def test_check_experiment_with_no_review_status_pushes_nothing(self): for status in [ NimbusExperiment.Status.DRAFT, NimbusExperiment.Status.ACCEPTED, NimbusExperiment.Status.LIVE, NimbusExperiment.Status.COMPLETE, ]: NimbusExperimentFactory.create(status=status) self.setup_kinto_no_pending_review() tasks.nimbus_check_kinto_push_queue() self.mock_push_task.assert_not_called()
def test_check_with_pending_review_before_timeout_aborts_early(self, ): NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.LAUNCH_APPROVE_WAITING, application=NimbusExperiment.Application.DESKTOP, ) self.setup_kinto_get_main_records([]) self.setup_kinto_pending_review() tasks.nimbus_check_kinto_push_queue_by_collection( settings.KINTO_COLLECTION_NIMBUS_DESKTOP) self.mock_kinto_client.patch_collection.assert_not_called() self.mock_push_task.assert_not_called() self.mock_update_task.assert_not_called() self.mock_end_task.assert_not_called()
def test_waiting_returns_any_waiting_experiments(self): NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.CREATED, application=NimbusExperiment.Application.IOS, ) desktop_live_waiting = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.LAUNCH_APPROVE_WAITING, application=NimbusExperiment.Application.DESKTOP, ) self.assertEqual( list( NimbusExperiment.objects.waiting([NimbusExperiment.Application.DESKTOP]) ), [desktop_live_waiting], )
def test_generate_nimbus_changelog_without_prior_change(self): experiment = NimbusExperimentFactory.create() self.assertEqual(experiment.changes.count(), 0) generate_nimbus_changelog(experiment, self.user, "test message") self.assertEqual(experiment.changes.count(), 1) change = experiment.changes.get() self.assertEqual(change.experiment, experiment) self.assertEqual(change.message, "test message") self.assertEqual(change.changed_by, self.user) self.assertEqual(change.old_status, None) self.assertEqual(change.old_status_next, None) self.assertEqual(change.old_publish_status, None) self.assertEqual(change.new_status, NimbusExperiment.Status.DRAFT) self.assertEqual(change.new_status_next, None) self.assertEqual(change.new_publish_status, NimbusExperiment.PublishStatus.IDLE) self.assertEqual( change.experiment_data, dict(NimbusExperimentChangeLogSerializer(experiment).data), )
def test_experiment_with_timeout_returns_changelog(self): user_email = "*****@*****.**" experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.LAUNCH_APPROVE_TIMEOUT ) response = self.query( """ query experimentBySlug($slug: String!) { experimentBySlug(slug: $slug) { timeout { changedBy { email } } } } """, variables={"slug": experiment.slug}, headers={settings.OPENIDC_EMAIL_HEADER: user_email}, ) content = json.loads(response.content) self.assertEqual(response.status_code, 200) experiment_data = content["data"]["experimentBySlug"] self.assertEqual( experiment_data["timeout"]["changedBy"]["email"], experiment.owner.email )
def test_recipe_json_returns_serialized_data(self): user_email = "*****@*****.**" experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.CREATED ) response = self.query( """ query experimentBySlug($slug: String!) { experimentBySlug(slug: $slug) { recipeJson } } """, variables={"slug": experiment.slug}, headers={settings.OPENIDC_EMAIL_HEADER: user_email}, ) content = json.loads(response.content) self.assertEqual(response.status_code, 200) experiment_data = content["data"]["experimentBySlug"] self.assertEqual( experiment_data["recipeJson"], json.dumps( NimbusExperimentSerializer(experiment).data, indent=2, sort_keys=True ), )
def test_experiment_with_review_request(self): user_email = "*****@*****.**" experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.LAUNCH_REVIEW_REQUESTED ) response = self.query( """ query experimentBySlug($slug: String!) { experimentBySlug(slug: $slug) { reviewRequest { changedBy { email } } } } """, variables={"slug": experiment.slug}, headers={settings.OPENIDC_EMAIL_HEADER: user_email}, ) self.assertEqual(response.status_code, 200, response.content) content = json.loads(response.content) experiment_data = content["data"]["experimentBySlug"] self.assertEqual( experiment_data["reviewRequest"]["changedBy"]["email"], experiment.owner.email )
def test_push_experiment_to_kinto_sends_fenix_experiment_data(self): experiment = NimbusExperimentFactory.create_with_status( NimbusExperiment.Status.DRAFT, application=NimbusExperiment.Application.FENIX, population_percent=Decimal("50.0"), ) tasks.nimbus_push_experiment_to_kinto(experiment.id) self.assertEqual(experiment.bucket_range.start, 0) self.assertEqual(experiment.bucket_range.count, 5000) data = NimbusExperimentSerializer(experiment).data self.mock_kinto_client.create_record.assert_called_with( data=data, collection=settings.KINTO_COLLECTION_NIMBUS_MOBILE, bucket=settings.KINTO_BUCKET, if_not_exists=True, ) self.assertTrue( NimbusChangeLog.objects.filter( experiment=experiment, changed_by__email=settings.KINTO_DEFAULT_CHANGELOG_USER, old_status=NimbusExperiment.Status.DRAFT, new_status=NimbusExperiment.Status.ACCEPTED, ).exists())
def test_experiment_no_rejection_data(self): user_email = "*****@*****.**" experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.CREATED ) response = self.query( """ query experimentBySlug($slug: String!) { experimentBySlug(slug: $slug) { rejection { changedBy { email } } } } """, variables={"slug": experiment.slug}, headers={settings.OPENIDC_EMAIL_HEADER: user_email}, ) self.assertEqual(response.status_code, 200, response.content) content = json.loads(response.content) experiment_data = content["data"]["experimentBySlug"] self.assertIsNone(experiment_data["rejection"])
def test_experiment_no_jexl_targeting_expression(self): user_email = "*****@*****.**" experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.CREATED, targeting_config_slug="", application=NimbusExperiment.Application.FENIX, ) response = self.query( """ query experimentBySlug($slug: String!) { experimentBySlug(slug: $slug) { jexlTargetingExpression } } """, variables={"slug": experiment.slug}, headers={settings.OPENIDC_EMAIL_HEADER: user_email}, ) self.assertEqual(response.status_code, 200, response.content) content = json.loads(response.content) experiment_data = content["data"]["experimentBySlug"] self.assertEqual( experiment_data["jexlTargetingExpression"], "true", )
def test_experiment_by_slug_not_ready_for_review(self): user_email = "*****@*****.**" experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.CREATED, hypothesis=NimbusExperiment.HYPOTHESIS_DEFAULT, ) response = self.query( """ query experimentBySlug($slug: String!) { experimentBySlug(slug: $slug) { readyForReview { message ready } } } """, variables={"slug": experiment.slug}, headers={settings.OPENIDC_EMAIL_HEADER: user_email}, ) self.assertEqual(response.status_code, 200, response.content) content = json.loads(response.content) experiment_data = content["data"]["experimentBySlug"] self.assertEqual( experiment_data["readyForReview"], { "message": {"hypothesis": ["Hypothesis cannot be the default value."]}, "ready": False, }, )
def test_paused_experiment_returns_date(self): user_email = "*****@*****.**" experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.LIVE_PAUSED, proposed_enrollment=7, ) live_change = experiment.changes.get( old_status=NimbusExperiment.Status.DRAFT, new_status=NimbusExperiment.Status.LIVE, ) live_change.changed_on = datetime.datetime(2021, 1, 1) live_change.save() response = self.query( """ query experimentBySlug($slug: String!) { experimentBySlug(slug: $slug) { isEnrollmentPaused enrollmentEndDate } } """, variables={"slug": experiment.slug}, headers={settings.OPENIDC_EMAIL_HEADER: user_email}, ) self.assertEqual(response.status_code, 200, response.content) content = json.loads(response.content) experiment_data = content["data"]["experimentBySlug"] self.assertEqual(experiment_data["isEnrollmentPaused"], True) self.assertEqual(experiment_data["enrollmentEndDate"], "2021-01-08")
def test_signoff_recommendations(self): user_email = "*****@*****.**" experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.CREATED, risk_brand=True, risk_revenue=True, risk_partner_related=True, ) response = self.query( """ query experimentBySlug($slug: String!) { experimentBySlug(slug: $slug) { signoffRecommendations { qaSignoff vpSignoff legalSignoff } } } """, variables={"slug": experiment.slug}, headers={settings.OPENIDC_EMAIL_HEADER: user_email}, ) self.assertEqual(response.status_code, 200, response.content) content = json.loads(response.content) experiment_data = content["data"]["experimentBySlug"] self.assertEqual(experiment_data["signoffRecommendations"]["qaSignoff"], True) self.assertEqual(experiment_data["signoffRecommendations"]["vpSignoff"], True) self.assertEqual(experiment_data["signoffRecommendations"]["legalSignoff"], True)
def test_experiments_with_branches_returns_branch_data(self): user_email = "*****@*****.**" experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.CREATED ) response = self.query( """ query { experiments { referenceBranch { slug } treatmentBranches { slug } } } """, headers={settings.OPENIDC_EMAIL_HEADER: user_email}, ) self.assertEqual(response.status_code, 200) content = json.loads(response.content) experiment_data = content["data"]["experiments"][0] self.assertEqual( experiment_data["referenceBranch"], {"slug": experiment.reference_branch.slug}, ) self.assertEqual( {b["slug"] for b in experiment_data["treatmentBranches"]}, {b.slug for b in experiment.treatment_branches}, )
def test_experiments_with_documentation_links_return_link_data(self): user_email = "*****@*****.**" experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.CREATED ) documentation_links = experiment.documentation_links.all() self.assert_(len(documentation_links) > 0) response = self.query( """ query { experiments { documentationLinks { title link } } } """, headers={settings.OPENIDC_EMAIL_HEADER: user_email}, ) self.assertEqual(response.status_code, 200) content = json.loads(response.content) experiment_data = content["data"]["experiments"][0] for key in ( "title", "link", ): self.assertEqual( {b[key] for b in experiment_data["documentationLinks"]}, {getattr(b, key) for b in documentation_links}, )
def test_form_saves_outcomes(self): experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.CREATED, primary_outcomes=[], secondary_outcomes=[], ) 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, "primary_outcomes": "outcome1, outcome2", "secondary_outcomes": "outcome3, outcome4", }, ) self.assertTrue(form.is_valid(), form.errors) experiment = form.save() self.assertEqual(experiment.primary_outcomes, ["outcome1", "outcome2"]) self.assertEqual(experiment.secondary_outcomes, ["outcome3", "outcome4"])
def test_experiment_by_slug_ready_for_review(self): user_email = "*****@*****.**" experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.CREATED ) response = self.query( """ query experimentBySlug($slug: String!) { experimentBySlug(slug: $slug) { name slug publicDescription readyForReview { message ready } } } """, variables={"slug": experiment.slug}, headers={settings.OPENIDC_EMAIL_HEADER: user_email}, ) self.assertEqual(response.status_code, 200, response.content) content = json.loads(response.content) experiment_data = content["data"]["experimentBySlug"] self.assertEqual(experiment_data["name"], experiment.name) self.assertEqual(experiment_data["slug"], experiment.slug) self.assertEqual( experiment_data["publicDescription"], experiment.public_description ) self.assertEqual( experiment_data["readyForReview"], {"message": {}, "ready": True} )
def test_generate_nimbus_changelog_with_prior_change(self): experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.CREATED) self.assertEqual(experiment.changes.count(), 1) experiment.status = NimbusExperiment.Status.DRAFT experiment.status_next = NimbusExperiment.Status.LIVE experiment.publish_status = NimbusExperiment.PublishStatus.REVIEW experiment.save() generate_nimbus_changelog(experiment, self.user, "test message") self.assertEqual(experiment.changes.count(), 2) change = experiment.changes.latest_change() self.assertEqual(change.experiment, experiment) self.assertEqual(change.message, "test message") self.assertEqual(change.changed_by, self.user) self.assertEqual(change.old_status, NimbusExperiment.Status.DRAFT) self.assertEqual(change.old_status_next, None) self.assertEqual(change.old_publish_status, NimbusExperiment.PublishStatus.IDLE) self.assertEqual(change.new_status, NimbusExperiment.Status.DRAFT) self.assertEqual(change.new_status_next, NimbusExperiment.Status.LIVE) self.assertEqual(change.new_publish_status, NimbusExperiment.PublishStatus.REVIEW) self.assertEqual( change.experiment_data, dict(NimbusExperimentChangeLogSerializer(experiment).data), )
def test_experiments(self): user_email = "*****@*****.**" experiment = NimbusExperimentFactory.create_with_lifecycle( NimbusExperimentFactory.Lifecycles.CREATED ) response = self.query( """ query { experiments { name slug publicDescription riskMitigationLink } } """, headers={settings.OPENIDC_EMAIL_HEADER: user_email}, ) self.assertEqual(response.status_code, 200) content = json.loads(response.content) experiments = content["data"]["experiments"] self.assertEqual(len(experiments), 1) for key in experiments[0]: self.assertEqual( experiments[0][key], str(getattr(experiment, to_snake_case(key))) )