def test_change_course_state(self):
"""
Verify that if marketing user change course state, owner role will be changed to `CourseTeam`.
"""
self.assertNotEqual(self.course_state.name, CourseStateChoices.Review)
factories.CourseUserRoleFactory(
course=self.course, role=PublisherUserRole.MarketingReviewer, user=self.user
)
course_team_user = UserFactory()
factories.CourseUserRoleFactory(
course=self.course, role=PublisherUserRole.CourseTeam, user=course_team_user
)
response = self.client.patch(
self.change_state_url,
data=json.dumps({'name': CourseStateChoices.Review}),
content_type=JSON_CONTENT_TYPE
)
self.assertEqual(response.status_code, 200)
self.course_state = CourseState.objects.get(course=self.course)
self.assertEqual(self.course_state.name, CourseStateChoices.Review)
self.assertEqual(self.course_state.owner_role, PublisherUserRole.CourseTeam)
# Verify that course is marked as reviewed by marketing.
self.assertTrue(self.course_state.marketing_reviewed)
subject = 'Review requested: {title}'.format(title=self.course.title)
self._assert_email_sent(course_team_user, subject)
def setUp(self):
super(CourseRunMarkAsReviewedEmailTests, self).setUp()
self.user = UserFactory()
self.user_2 = UserFactory()
self.user_3 = UserFactory()
self.seat = factories.SeatFactory()
self.course_run = self.seat.course_run
self.course = self.course_run.course
self.course.organizations.add(OrganizationFactory())
# add user in course-user-role table
factories.CourseUserRoleFactory(course=self.course,
role=PublisherUserRole.CourseTeam,
user=self.user_2)
factories.CourseUserRoleFactory(course=self.course,
role=PublisherUserRole.Publisher,
user=self.user_3)
self.course_run_state = factories.CourseRunStateFactory(
course_run=self.course_run)
self.course_run.lms_course_id = 'course-v1:edX+DemoX+Demo_Course'
self.course_run.save()
toggle_switch('enable_publisher_email_notifications', True)
def test_mark_as_reviewed(self):
"""
Verify that user can mark course as reviewed.
"""
self.course_state.name = CourseStateChoices.Review
self.course_state.save()
factories.CourseUserRoleFactory(
course=self.course, role=PublisherUserRole.MarketingReviewer, user=self.user
)
course_team_user = UserFactory()
factories.CourseUserRoleFactory(
course=self.course, role=PublisherUserRole.CourseTeam, user=course_team_user
)
response = self.client.patch(
self.change_state_url,
data=json.dumps({'name': CourseStateChoices.Approved}),
content_type=JSON_CONTENT_TYPE
)
self.assertEqual(response.status_code, 200)
self.course_state = CourseState.objects.get(course=self.course)
self.assertEqual(self.course_state.name, CourseStateChoices.Approved)
subject = 'Review complete: {title}'.format(title=self.course.title)
self._assert_email_sent(course_team_user, subject)
def setUp(self):
super(CourseTests, self).setUp()
self.org_extension_1 = factories.OrganizationExtensionFactory()
self.org_extension_2 = factories.OrganizationExtensionFactory()
self.course = factories.CourseFactory(organizations=[self.org_extension_1.organization])
self.course2 = factories.CourseFactory(organizations=[self.org_extension_2.organization])
self.user1 = UserFactory()
self.user2 = UserFactory()
self.user3 = UserFactory()
self.user1.groups.add(self.org_extension_1.group)
self.user2.groups.add(self.org_extension_2.group)
# add user in course-user-role table
factories.CourseUserRoleFactory(
course=self.course, role=PublisherUserRole.ProjectCoordinator, user=self.user1
)
factories.CourseUserRoleFactory(
course=self.course, role=PublisherUserRole.MarketingReviewer, user=self.user2
)
factories.CourseUserRoleFactory(
course=self.course, role=PublisherUserRole.Publisher, user=self.user3
)
def test_update_preview_url(self):
"""Verify the user can update course preview url."""
self.course_run.lms_course_id = 'course-v1:testX+TC167+2018T1'
self.course_run.save()
preview_url = 'https://example.com/abc/course'
factories.CourseRunStateFactory.create(course_run=self.course_run, owner_role=PublisherUserRole.Publisher)
factories.CourseUserRoleFactory(
course=self.course_run.course, role=PublisherUserRole.Publisher
)
course_team_role = factories.CourseUserRoleFactory(
course=self.course_run.course, role=PublisherUserRole.CourseTeam
)
response = self._make_request(preview_url)
self.assertEqual(response.status_code, 200)
course_run = CourseRun.objects.get(id=self.course_run.id)
self.assertEqual(course_run.preview_url, preview_url)
course_key = CourseKey.from_string(course_run.lms_course_id)
subject = 'Review requested: Preview for {course_name} {run_number}'.format(
course_name=self.course_run.course.title,
run_number=course_key.run
)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual([course_team_role.user.email], mail.outbox[0].to)
self.assertEqual(str(mail.outbox[0].subject), subject)
def test_change_course_state(self):
"""
Verify that marketing user can change course workflow state
and owner role changed to `CourseTeam`.
"""
self.assertNotEqual(self.course_state.name, CourseStateChoices.Review)
factories.CourseUserRoleFactory(
course=self.course,
role=PublisherUserRole.MarketingReviewer,
user=self.user)
course_team_user = UserFactory()
factories.CourseUserRoleFactory(course=self.course,
role=PublisherUserRole.CourseTeam,
user=course_team_user)
response = self.client.patch(self.change_state_url,
data=json.dumps(
{'name': CourseStateChoices.Review}),
content_type=JSON_CONTENT_TYPE)
self.assertEqual(response.status_code, 200)
self.course_state = CourseState.objects.get(course=self.course)
self.assertEqual(self.course_state.name, CourseStateChoices.Review)
self.assertEqual(self.course_state.owner_role,
PublisherUserRole.CourseTeam)
subject = 'Changes to {title} are ready for review'.format(
title=self.course.title)
self._assert_email_sent(course_team_user, subject)
def setUp(self):
super(CourseRunPublishedEmailTests, self).setUp()
self.user = UserFactory()
self.run_state = factories.CourseRunStateFactory()
self.course_run = self.run_state.course_run
self.course = self.course_run.course
factories.CourseUserRoleFactory(course=self.course,
role=PublisherUserRole.CourseTeam,
user=self.user)
factories.CourseUserRoleFactory(course=self.course,
role=PublisherUserRole.Publisher,
user=UserFactory())
def test_save_method_add_course_user_roles(self):
"""
Verify that save method will not create the duplicate course user roles.
"""
# for course 3 add course roles
user = UserFactory()
course3 = CourseFactory()
course3.organizations.add(self.organization)
factories.CourseUserRoleFactory(
course=course3,
role=PublisherUserRole.MarketingReviewer,
user=user)
# for course 4 add course roles
project_coordinator = UserFactory()
course4 = CourseFactory()
course4.organizations.add(self.organization)
factories.CourseUserRoleFactory(
course=course4,
role=PublisherUserRole.ProjectCoordinator,
user=project_coordinator)
test_user = UserFactory()
post_data = {
'organization': self.organization.id,
'user': test_user.id,
'role': PublisherUserRole.MarketingReviewer
}
self.client.post(self.admin_page_url, data=post_data)
# for course-4 course-user-role does not change
self.assertTrue(
course4.course_user_roles.filter(
role=PublisherUserRole.ProjectCoordinator,
user=project_coordinator).exists())
# for course-3 course-user-role also changes to test_user
self.assertTrue(
course3.course_user_roles.filter(
role=PublisherUserRole.MarketingReviewer,
user=test_user).exists())
self.assertTrue(
self.course1.course_user_roles.filter(
role=PublisherUserRole.MarketingReviewer,
user=test_user).exists())
self.assertTrue(
self.course2.course_user_roles.filter(
role=PublisherUserRole.MarketingReviewer,
user=test_user).exists())
def setUp(self):
super(CourseChangeRoleAssignmentEmailTests, self).setUp()
self.user = UserFactory()
self.marketing_role = factories.CourseUserRoleFactory(
role=PublisherUserRole.MarketingReviewer, user=self.user)
self.course = self.marketing_role.course
factories.CourseUserRoleFactory(course=self.course,
role=PublisherUserRole.Publisher)
factories.CourseUserRoleFactory(
course=self.course, role=PublisherUserRole.ProjectCoordinator)
factories.CourseUserRoleFactory(course=self.course,
role=PublisherUserRole.CourseTeam)
toggle_switch('enable_publisher_email_notifications', True)
def setUp(self):
super(CourseChangeRoleAssignmentEmailTests, self).setUp()
self.user = UserFactory()
self.marketing_role = factories.CourseUserRoleFactory(
role=PublisherUserRole.MarketingReviewer, user=self.user)
self.course = self.marketing_role.course
self.course_team_role = factories.CourseUserRoleFactory(
course=self.course,
role=PublisherUserRole.CourseTeam,
user=self.user)
factories.CourseUserRoleFactory(course=self.course,
role=PublisherUserRole.Publisher)
factories.CourseUserRoleFactory(
course=self.course, role=PublisherUserRole.ProjectCoordinator)
def test_course_autocomplete_with_internal_user(self):
""" Verify course autocomplete returns all courses for publisher admin. """
self.user.groups.remove(self.organization_extension.group)
self.user.groups.add(Group.objects.get(name=INTERNAL_USER_GROUP_NAME))
factories.CourseUserRoleFactory(course=self.course2, user=self.user, role=PublisherUserRole.MarketingReviewer)
response = self.client.get(self.course_autocomplete_url.format(title='test'))
self._assert_response(response, 1)
def test_update_course_key(self):
"""
Test that internal user can update `lms_course_id` for a course run.
"""
# By default `lms_course_id` and `changed_by` are None
self.assert_course_key_and_changed_by()
# create course team role for email
factories.CourseUserRoleFactory(
course=self.course_run.course, role=PublisherUserRole.CourseTeam, user=self.user
)
lms_course_id = 'course-v1:edxTest+TC12+2050Q1'
response = self.client.patch(
self.update_course_run_url,
data=json.dumps({'lms_course_id': lms_course_id}),
content_type=JSON_CONTENT_TYPE
)
self.assertEqual(response.status_code, 200)
# Verify that `lms_course_id` and `changed_by` are not None
self.assert_course_key_and_changed_by(lms_course_id=lms_course_id, changed_by=self.user)
course_key = CourseKey.from_string(lms_course_id)
# Assert email sent
self.assert_email_sent(
reverse('publisher:publisher_course_run_detail', kwargs={'pk': self.course_run.id}),
'Studio URL created: {title} {run}'.format(title=self.course_run.course.title, run=course_key.run),
'has created a Studio URL'
)
def test_course_published_email(self):
"""
Verify that course published email functionality works fine.
"""
project_coordinator = UserFactory()
factories.CourseUserRoleFactory(
course=self.course,
role=PublisherUserRole.ProjectCoordinator,
user=project_coordinator)
self.course_run.lms_course_id = 'course-v1:testX+test45+2017T2'
self.course_run.save()
person = PersonFactory()
DiscoveryCourseRunFactory(key=self.course_run.lms_course_id,
staff=[person])
emails.send_course_run_published_email(self.course_run, self.site)
course_key = CourseKey.from_string(self.course_run.lms_course_id)
subject = 'Publication complete: About page for {course_name} {run_number}'.format(
course_name=self.course_run.course.title,
run_number=course_key.run)
assert len(mail.outbox) == 1
message = mail.outbox[0]
assert message.to == [self.user.email]
assert message.cc == [project_coordinator.email]
self.assertEqual(str(mail.outbox[0].subject), subject)
body = mail.outbox[0].body.strip()
self.assertIn(self.course_run.preview_url, body)
self.assertIn('has been published', body)
def setUp(self):
super(CourseRunPublishedEmailTests, self).setUp()
self.user = UserFactory()
self.run_state = factories.CourseRunStateFactory()
self.course_run = self.run_state.course_run
self.course = self.course_run.course
factories.CourseUserRoleFactory(course=self.course,
role=PublisherUserRole.CourseTeam,
user=self.user)
factories.CourseUserRoleFactory(course=self.course,
role=PublisherUserRole.Publisher,
user=UserFactory())
toggle_switch('enable_publisher_email_notifications', True)
def setUp(self):
super(CourseRoleAssignmentViewTests, self).setUp()
self.course = factories.CourseFactory()
# Create an internal user group and assign four users because we have
# four different roles for every course.
self.internal_user = UserFactory()
self.internal_user_group = Group.objects.get(
name=INTERNAL_USER_GROUP_NAME)
self.internal_user_group.user_set.add(self.internal_user)
self.other_internal_users = UserFactory.create_batch(4)
self.internal_user_group.user_set.add(*self.other_internal_users)
self.organization_extension = factories.OrganizationExtensionFactory()
self.course.organizations.add(self.organization_extension.organization)
# Create three internal user course roles for internal users against a course
# so we can test change role assignment on these roles.
roles = [role for role, __ in PublisherUserRole.choices]
for user, role in zip(self.other_internal_users, roles):
factories.CourseUserRoleFactory(course=self.course,
user=user,
role=role)
self.client.login(username=self.internal_user.username,
password=USER_PASSWORD)
def setUpClass(cls):
super(CourseStateTests, cls).setUpClass()
cls.course_state = factories.CourseStateFactory(name=CourseStateChoices.Draft)
cls.user = UserFactory()
factories.CourseUserRoleFactory(
course=cls.course_state.course, role=PublisherUserRole.CourseTeam, user=cls.user
)
def setUp(self):
super(CourseUserRoleTests, self).setUp()
self.course_user_role = factories.CourseUserRoleFactory(
role=PublisherUserRole.ProjectCoordinator)
self.course = factories.CourseFactory()
self.user = UserFactory()
self.marketing_reviewer_role = PublisherUserRole.MarketingReviewer
def test_email_sent_by_course_team(self):
""" Verify that email works successfully."""
factories.CourseUserRoleFactory(
course=self.course, role=PublisherUserRole.MarketingReviewer, user=self.user
)
emails.send_email_for_mark_as_reviewed_course_run(self.course_run_state.course_run, self.user_2)
self.assert_email_sent(self.user)
def test_published_course_run_editing_email(self):
"""
Verify that on edit the published course-run email send to publisher.
"""
factories.CourseUserRoleFactory(
course=self.course,
role=PublisherUserRole.ProjectCoordinator,
user=self.user)
self.course_run.lms_course_id = 'course-v1:testX+test45+2017T2'
self.course_run.save()
emails.send_email_for_published_course_run_editing(self.course_run)
course_key = CourseKey.from_string(self.course_run.lms_course_id)
subject = 'Changes to published course run: {title} {run_number}'.format(
title=self.course_run.course.title, run_number=course_key.run)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual([self.course.publisher.email], mail.outbox[0].to)
self.assertEqual(str(mail.outbox[0].subject), subject)
body = mail.outbox[0].body.strip()
self.assertIn(
'has made changes to the following published course run.', body)
page_path = reverse('publisher:publisher_course_run_detail',
kwargs={'pk': self.run_state.course_run.id})
self.assertIn(page_path, body)
def setUp(self):
super(CourseCreatedEmailTests, self).setUp()
self.user = UserFactory()
self.course_run = factories.CourseRunFactory()
# add user in course-user-role table
factories.CourseUserRoleFactory(
course=self.course_run.course,
role=PublisherUserRole.ProjectCoordinator,
user=self.user)
self.course_team = UserFactory()
factories.CourseUserRoleFactory(course=self.course_run.course,
role=PublisherUserRole.CourseTeam,
user=self.course_team)
UserAttributeFactory(user=self.user, enable_email_notification=True)
def test_has_role_for_course(self):
"""
Verify the function returns a boolean indicating if the user has a role for course.
"""
self.assertFalse(has_role_for_course(self.course, self.user))
factories.CourseUserRoleFactory(course=self.course, user=self.user)
self.assertTrue(has_role_for_course(self.course, self.user))
def test_email_sent_by_course_team(self):
""" Verify that email works successfully."""
factories.CourseUserRoleFactory(
course=self.course, role=PublisherUserRole.MarketingReviewer, user=self.user
)
emails.send_email_for_send_for_review_course_run(self.course_run_state.course_run, self.user_2)
subject = 'Changes to {title} are ready for review'.format(title=self.course_run.course.title)
self.assert_email_sent(subject, self.user)
def test_publisher(self):
""" Verify that the publisher property returns user if exist. """
self.assertIsNone(self.course2.publisher)
factories.CourseUserRoleFactory(
course=self.course2, user=self.user1, role=PublisherUserRole.Publisher
)
self.assertEqual(self.user1, self.course2.publisher)
def test_marketing_reviewer(self):
""" Verify that the marketing_reviewer property returns user if exist. """
self.assertIsNone(self.course2.marketing_reviewer)
factories.CourseUserRoleFactory(
course=self.course2, user=self.user1, role=PublisherUserRole.MarketingReviewer
)
self.assertEqual(self.user1, self.course2.marketing_reviewer)
def test_course_team_admin(self):
""" Verify that the course_team_admin property returns user if exist. """
self.assertIsNone(self.course2.course_team_admin)
factories.CourseUserRoleFactory(
course=self.course2, user=self.user1, role=PublisherUserRole.CourseTeam
)
self.assertEqual(self.user1, self.course2.course_team_admin)
def test_email_sent_by_course_team(self):
""" Verify that email works successfully for course team user."""
factories.CourseUserRoleFactory(
course=self.course,
role=PublisherUserRole.ProjectCoordinator,
user=self.user)
emails.send_email_for_mark_as_reviewed_course_run(
self.course_run_state.course_run, self.user_2, self.site)
self.assert_email_sent(self.user)
def test_email_sent_to_publisher(self):
""" Verify that email works successfully."""
factories.CourseUserRoleFactory(
course=self.course,
role=PublisherUserRole.ProjectCoordinator,
user=self.user)
emails.send_email_to_publisher(self.course_run_state.course_run,
self.user)
self.assert_email_sent(self.user_3)
def test_email_not_sent_by_project_coordinator(self):
""" Verify that no email is sent if approving person is project coordinator. """
factories.CourseUserRoleFactory(
course=self.course,
role=PublisherUserRole.ProjectCoordinator,
user=self.user)
emails.send_email_for_mark_as_reviewed_course_run(
self.course_run_state.course_run, self.user)
self.assertEqual(len(mail.outbox), 0)
def test_email_with_roles(self):
""" Verify that emails send to the users against course-user-roles also."""
user_4 = UserFactory()
user_5 = UserFactory()
# assign the role against a course
factories.CourseUserRoleFactory(
course=self.course,
role=PublisherUserRole.MarketingReviewer,
user=user_4)
factories.CourseUserRoleFactory(
course=self.course,
role=PublisherUserRole.ProjectCoordinator,
user=user_5)
self.create_comment(content_object=self.course_run)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual([self.user_2.email, user_4.email, user_5.email],
mail.outbox[0].to)
def setUpClass(cls):
super(CourseRunStateTests, cls).setUpClass()
cls.seat = factories.SeatFactory(type=Seat.VERIFIED, price=100)
cls.course_run_state = factories.CourseRunStateFactory(
course_run=cls.seat.course_run, name=CourseRunStateChoices.Draft)
cls.course_run = cls.course_run_state.course_run
cls.course = cls.course_run.course
cls.user = UserFactory()
factories.CourseStateFactory(name=CourseStateChoices.Approved,
course=cls.course)
factories.CourseUserRoleFactory(course=cls.course_run.course,
role=PublisherUserRole.CourseTeam,
user=cls.user)
factories.CourseUserRoleFactory(
course=cls.course_run.course,
role=PublisherUserRole.MarketingReviewer,
user=UserFactory())
