def test_retrieve_not_staff(self):
""" Verify the endpoint returns a list of all organizations. """
org1 = OrganizationFactory.create(partner=self.partner)
org2 = OrganizationFactory.create(partner=self.partner)
OrganizationFactory.create(partner=self.partner)
url = reverse('api:v1:organization-detail', kwargs={'uuid': org2.uuid})
extension1 = publisher_factories.OrganizationExtensionFactory(
organization=org1)
publisher_factories.OrganizationExtensionFactory(organization=org2)
assign_perm(OrganizationExtension.VIEW_COURSE, extension1.group,
extension1)
self.non_staff_user.groups.add(extension1.group)
# Check Staff user get all groups
response = self.client.get(url)
assert response.status_code == 200
self.assert_response_data_valid(response, org2, many=False)
# Check non staff user gets 1 group
self.client.logout()
self.client.login(username=self.non_staff_user.username,
password=USER_PASSWORD)
response = self.client.get(url)
assert response.status_code == 404
url = reverse('api:v1:organization-detail', kwargs={'uuid': org1.uuid})
response = self.client.get(url)
assert response.status_code == 200
self.assert_response_data_valid(response, org1, many=False)
def test_list_not_staff(self):
""" Verify the endpoint returns a list of all organizations. """
org1 = OrganizationFactory.create(partner=self.partner)
org2 = OrganizationFactory.create(partner=self.partner)
OrganizationFactory.create(partner=self.partner)
extension1 = publisher_factories.OrganizationExtensionFactory(
organization=org1)
publisher_factories.OrganizationExtensionFactory(organization=org2)
assign_perm(OrganizationExtension.VIEW_COURSE, extension1.group,
extension1)
self.non_staff_user.groups.add(extension1.group)
# Check Staff user get all groups
response = self.client.get(self.list_path)
assert response.status_code == 200
self.assert_response_data_valid(response, Organization.objects.all())
# Check non staff user gets 1 group
self.client.logout()
self.client.login(username=self.non_staff_user.username,
password=USER_PASSWORD)
response = self.client.get(self.list_path)
assert response.status_code == 200
self.assert_response_data_valid(response, [org1])
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 setUp(self):
super(PublisherUtilsTests, self).setUp()
self.user = UserFactory()
self.organization_extension = factories.OrganizationExtensionFactory()
self.course = factories.CourseFactory(organizations=[self.organization_extension.organization])
self.admin_group = Group.objects.get(name=ADMIN_GROUP_NAME)
self.internal_user_group = Group.objects.get(name=INTERNAL_USER_GROUP_NAME)
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 setUp(self):
super(AutoCompletePersonTests, self).setUp()
self.user = UserFactory(is_staff=True)
self.client.login(username=self.user.username, password=USER_PASSWORD)
first_instructor = PersonFactory(given_name="First",
family_name="Instructor")
second_instructor = PersonFactory(given_name="Second",
family_name="Instructor")
self.instructors = [first_instructor, second_instructor]
self.organizations = OrganizationFactory.create_batch(3)
self.organization_extensions = []
for instructor in self.instructors:
PositionFactory(organization=self.organizations[0],
title="professor",
person=instructor)
for organization in self.organizations:
org_ex = publisher_factories.OrganizationExtensionFactory(
organization=organization)
self.organization_extensions.append(org_ex)
disco_course = CourseFactory(
authoring_organizations=[self.organizations[0]])
disco_course2 = CourseFactory(
authoring_organizations=[self.organizations[1]])
CourseRunFactory(course=disco_course, staff=[first_instructor])
CourseRunFactory(course=disco_course2, staff=[second_instructor])
self.user.groups.add(self.organization_extensions[0].group)
def test_is_on_new_pub_fe(self):
def staff_user_always_false(user):
user.is_staff = True
self.assertFalse(is_on_new_pub_fe(user))
user.is_staff = False
# When no ORGS_ON_OLD_PUBLISHER list present
self.assertFalse(is_on_new_pub_fe(self.user))
with self.settings(ORGS_ON_OLD_PUBLISHER=self.organization_extension.
organization.key):
# When ORGS_ON_OLD_PUBLISHER list present and user has no orgs
self.assertTrue(is_on_new_pub_fe(self.user))
staff_user_always_false(self.user)
self.user.groups.add(self.organization_extension.group)
with self.settings(ORGS_ON_OLD_PUBLISHER=self.organization_extension.
organization.key):
# When ORGS_ON_OLD_PUBLISHER list present and user belongs to an org in the list
self.assertFalse(is_on_new_pub_fe(self.user))
staff_user_always_false(self.user)
with self.settings(ORGS_ON_OLD_PUBLISHER='example-key'):
# When ORGS_ON_NEW_PUB_FE list present and user belongs to org not in the list
self.assertTrue(is_on_new_pub_fe(self.user))
with self.settings(ORGS_ON_OLD_PUBLISHER=self.organization_extension.
organization.key):
org_ext = factories.OrganizationExtensionFactory()
self.user.groups.add(self.organization_extension.group)
self.user.groups.add(org_ext.group)
# When ORGS_ON_OLD_PUBLISHER list present and user belongs to orgs both on and off the list
self.assertFalse(is_on_new_pub_fe(self.user))
def setUp(self):
super(AutoCompletePersonTests, self).setUp()
self.user = UserFactory(is_staff=True)
self.client.login(username=self.user.username, password=USER_PASSWORD)
self.courses = factories.CourseFactory.create_batch(
3, title='Some random course title')
for course in self.courses:
factories.CourseRunFactory(course=course)
self.organizations = OrganizationFactory.create_batch(3)
self.organization_extensions = []
for organization in self.organizations:
self.organization_extensions.append(
factories.OrganizationExtensionFactory(
organization=organization))
self.user.groups.add(self.organization_extensions[0].group)
first_instructor = PersonFactory(given_name="First",
family_name="Instructor")
second_instructor = PersonFactory(given_name="Second",
family_name="Instructor")
self.instructors = [first_instructor, second_instructor]
for instructor in self.instructors:
PositionFactory(organization=self.organizations[0],
title="professor",
person=instructor)
def setUp(self):
super(CreateCoursesTests, self).setUp()
transcript_languages = LanguageTag.objects.all()[:2]
self.subjects = SubjectFactory.create_batch(3)
self.course = CourseFactory(subjects=self.subjects)
self.command_name = 'import_metadata_courses'
self.command_args = ['--start_id={}'.format(self.course.id), '--end_id={}'.format(self.course.id)]
# create multiple course-runs against course.
course_runs = CourseRunFactory.create_batch(
3, course=self.course, transcript_languages=transcript_languages,
language=transcript_languages[0],
short_description_override='Testing description'
)
canonical_course_run = course_runs[0]
for seat_type in ['honor', 'credit', 'verified']: # to avoid same type seat creation.
SeatFactory(course_run=canonical_course_run, type=seat_type)
staff = PersonFactory.create_batch(2)
canonical_course_run.staff.add(*staff)
self.course.canonical_course_run = canonical_course_run
self.course.save()
# create org and assign to the course-metadata
self.forganization_extension = factories.OrganizationExtensionFactory()
self.organization = self.forganization_extension.organization
self.course.authoring_organizations.add(self.organization)
def setUp(self):
super(CourseStateTests, self).setUp()
self.course = self.course_state.course
self.course.image = make_image_file('test_banner.jpg')
self.course.save()
self.course.organizations.add(factories.OrganizationExtensionFactory().organization)
def setUp(self):
super().setUp()
self.user = UserFactory.create(username="******",
password=USER_PASSWORD)
self.client.login(username=self.user.username, password=USER_PASSWORD)
self.internal_user_group = Group.objects.get(
name=INTERNAL_USER_GROUP_NAME)
self.user.groups.add(self.internal_user_group)
self.expected_user = UserFactory()
self.organization_extension = factories.OrganizationExtensionFactory()
def setUp(self):
super(OrganizationGroupUserViewTests, self).setUp()
user = UserFactory.create(username="******", password=USER_PASSWORD)
self.client.login(username=user.username, password=USER_PASSWORD)
organization_extension = factories.OrganizationExtensionFactory()
self.org_user1 = UserFactory.create(full_name="org user1")
self.org_user2 = UserFactory.create(first_name='', last_name='', full_name='')
organization_extension.group.user_set.add(*[self.org_user1, self.org_user2])
self.organization = organization_extension.organization
def setUp(self):
super(OrganizationGroupUserViewTests, self).setUp()
self.user = UserFactory.create(username="******", password=USER_PASSWORD)
self.client.login(username=self.user.username, password=USER_PASSWORD)
self.internal_user_group = Group.objects.get(name=INTERNAL_USER_GROUP_NAME)
self.user.groups.add(self.internal_user_group)
organization_extension = factories.OrganizationExtensionFactory()
self.org_user1 = UserFactory.create(full_name="org user1")
self.org_user2 = UserFactory.create(first_name='', last_name='', full_name='')
organization_extension.group.user_set.add(*[self.org_user1, self.org_user2])
self.organization = organization_extension.organization
def setUp(self):
super(CoursesAutoCompleteTests, self).setUp()
self.user = UserFactory()
self.course = factories.CourseFactory(title='Test course 1')
self.course2 = factories.CourseFactory(title='Test course 2')
self.organization_extension = factories.OrganizationExtensionFactory()
self.course.organizations.add(self.organization_extension.organization)
self.user.groups.add(self.organization_extension.group)
assign_perm(
OrganizationExtension.VIEW_COURSE, self.organization_extension.group, self.organization_extension
)
self.client.login(username=self.user.username, password=USER_PASSWORD)
self.course_autocomplete_url = reverse('publisher:api:course-autocomplete') + '?q={title}'
def setUp(self):
super(ChangeCourseStateViewTests, self).setUp()
self.course_state = factories.CourseStateFactory(name=CourseStateChoices.Draft)
self.user = UserFactory()
self.user.groups.add(Group.objects.get(name=INTERNAL_USER_GROUP_NAME))
self.course = self.course_state.course
self.course.image = make_image_file('test_banner.jpg')
self.course.save()
self.organization_extension = factories.OrganizationExtensionFactory()
self.course.organizations.add(self.organization_extension.organization)
factories.UserAttributeFactory(user=self.user, enable_email_notification=True)
toggle_switch('enable_publisher_email_notifications', True)
self.change_state_url = reverse('publisher:api:change_course_state', kwargs={'pk': self.course_state.id})
self.client.login(username=self.user.username, password=USER_PASSWORD)
def setUp(self):
super(CommentsEmailTests, self).setUp()
self.user = UserFactory()
self.user_2 = UserFactory()
self.user_3 = UserFactory()
self.site = Site.objects.get(pk=settings.SITE_ID)
self.organization_extension = factories.OrganizationExtensionFactory()
self.seat = factories.SeatFactory()
self.course_run = self.seat.course_run
self.course = self.course_run.course
self.course.organizations.add(self.organization_extension.organization)
# NOTE: We intentionally do NOT create an attribute for user_2.
# By default this user WILL receive email notifications.
# add user in course-user-role table
factories.CourseUserRoleFactory(
course=self.course,
role=PublisherUserRole.ProjectCoordinator,
user=self.user)
factories.CourseUserRoleFactory(
course=self.course,
role=PublisherUserRole.ProjectCoordinator,
user=self.user_2)
factories.CourseUserRoleFactory(
course=self.course,
role=PublisherUserRole.ProjectCoordinator,
user=self.user_3)
UserAttributeFactory(user=self.user, enable_email_notification=True)
UserAttributeFactory(user=self.user_3, enable_email_notification=False)
toggle_switch('enable_publisher_email_notifications', True)
self.url = 'http://www.test.com'
def setUp(self):
super(UpdateCourseRunViewTests, self).setUp()
self.course_run = factories.CourseRunFactory()
self.user = UserFactory()
self.user.groups.add(Group.objects.get(name=INTERNAL_USER_GROUP_NAME))
self.organization_extension = factories.OrganizationExtensionFactory()
self.course_run.course.organizations.add(self.organization_extension.organization)
self.update_course_run_url = reverse(
'publisher:api:update_course_run', kwargs={'pk': self.course_run.id}
)
factories.CourseUserRoleFactory(
role=PublisherUserRole.ProjectCoordinator,
course=self.course_run.course,
user=self.user
)
factories.UserAttributeFactory(user=self.user, enable_email_notification=True)
toggle_switch('enable_publisher_email_notifications', True)
self.client.login(username=self.user.username, password=USER_PASSWORD)
def setUpClass(cls):
super().setUpClass()
cls.user = UserFactory(is_staff=True)
cls.courses = factories.CourseFactory.create_batch(
3, title='Some random course title')
first_instructor = PersonFactory(given_name="First",
family_name="Instructor")
second_instructor = PersonFactory(given_name="Second",
family_name="Instructor")
cls.instructors = [first_instructor, second_instructor]
cls.organizations = OrganizationFactory.create_batch(3)
cls.organization_extensions = []
for instructor in cls.instructors:
PositionFactory(organization=cls.organizations[0],
title="professor",
person=instructor)
cls.course_runs = [
factories.CourseRunFactory(course=course) for course in cls.courses
]
for organization in cls.organizations:
cls.organization_extensions.append(
factories.OrganizationExtensionFactory(
organization=organization))
disco_course = CourseFactory(
authoring_organizations=[cls.organizations[0]])
disco_course2 = CourseFactory(
authoring_organizations=[cls.organizations[1]])
CourseRunFactory(course=disco_course, staff=[first_instructor])
CourseRunFactory(course=disco_course2, staff=[second_instructor])
cls.user.groups.add(cls.organization_extensions[0].group)
def setUp(self):
super(GroupOrganizationTests, self).setUp()
self.organization_extension = factories.OrganizationExtensionFactory()
self.group_2 = factories.GroupFactory()
