def setUpTestData(cls):
super(APITests, cls).setUpTestData()
# create an user
cls.user = UserFactory.create()
# create the programs
cls.program1 = ProgramFactory.create(live=True)
cls.program2 = ProgramFactory.create(live=True)
def setUpTestData(cls):
super(APITests, cls).setUpTestData()
# create an user
cls.user = UserFactory.create()
# create the programs
cls.program1 = ProgramFactory.create(live=True)
cls.program2 = ProgramFactory.create(live=True)
def test_doesnt_list_unlive_programs(self):
"""Not-live programs should NOT show up"""
ProgramFactory.create(live=False)
resp = self.client.get(reverse('program-list'))
assert len(resp.json()) == 0
def test_roles_can_see_profile(self, role_to_set):
"""
Staff and Instructors can see private profile of user with same program
"""
# Create a private profile
new_user = SocialProfileFactory.create(
verified_micromaster_user=False,
account_privacy=Profile.PRIVATE,
).user
program = ProgramFactory.create()
ProgramEnrollment.objects.create(
program=program,
user=new_user,
)
# Make self.unverified_user a staff of that program
role = Role.objects.create(
user=self.user,
program=program,
role=role_to_set,
)
request = Mock(user=self.user)
view = Mock(kwargs={'user': self.get_social_auth_uid(new_user)})
assert self.perm.has_permission(request, view) is True
# Change role.program and assert that user no longer has permission to see private profile
role.program = ProgramFactory.create()
role.save()
with self.assertRaises(Http404):
self.perm.has_permission(request, view)
def setUpTestData(cls):
super(SearchTests, cls).setUpTestData()
# create some students
with mute_signals(post_save):
cls.students = [(ProfileFactory.create(filled_out=True)).user for _ in range(30)]
# create the programs
cls.program1 = ProgramFactory.create(live=True)
cls.program2 = ProgramFactory.create(live=True)
cls.program3 = ProgramFactory.create(live=True)
# enroll the users in the programs
for num, student in enumerate(cls.students):
if num % 3 == 0:
program = cls.program1
elif num % 3 == 1:
program = cls.program2
else:
program = cls.program3
ProgramEnrollmentFactory.create(
user=student,
program=program
)
# create an user with a role for one program
cls.staff = UserFactory.create()
Role.objects.create(
user=cls.staff,
program=cls.program1,
role=Staff.ROLE_ID
)
# search URL
cls.search_url = reverse('search_api', kwargs={'elastic_url': ''})
def test_roles_can_see_profile(self, role_to_set):
"""
Staff and Instructors can see private profile of user with same program
"""
# Create a private profile
new_user = SocialProfileFactory.create(
verified_micromaster_user=False,
account_privacy=Profile.PRIVATE,
).user
program = ProgramFactory.create()
ProgramEnrollment.objects.create(
program=program,
user=new_user,
)
# Make self.unverified_user a staff of that program
role = Role.objects.create(
user=self.user,
program=program,
role=role_to_set,
)
request = Mock(user=self.user)
view = Mock(kwargs={'user': self.get_social_auth_uid(new_user)})
assert self.perm.has_permission(request, view) is True
# Change role.program and assert that user no longer has permission to see private profile
role.program = ProgramFactory.create()
role.save()
with self.assertRaises(Http404):
self.perm.has_permission(request, view)
def test_program_liveness(self):
"""Verify only 'live' program visible on homepage"""
program_live_true = ProgramFactory.create(live=True)
program_live_false = ProgramFactory.create(live=False)
response = self.client.get('/')
self.assertContains(response, program_live_true.title, status_code=200)
self.assertNotContains(response,
program_live_false.title,
status_code=200)
def test_program_order(self):
"""
Assert that programs are output in id order
"""
for i in range(10):
ProgramFactory.create(live=True, title="Program {}".format(i + 1))
response = self.client.get("/")
content = response.content.decode('utf-8')
indexes = [content.find("Program {}".format(i + 1)) for i in range(10)]
assert indexes == sorted(indexes)
def setUpTestData(cls):
super(ProgramEnrollmentTests, cls).setUpTestData()
cls.user1 = UserFactory.create()
cls.user2 = UserFactory.create()
cls.program1 = ProgramFactory.create(live=True)
cls.program2 = ProgramFactory.create(live=True)
cls.program3 = ProgramFactory.create(live=True)
cls.url = reverse('user_program_enrollments')
def test_program_order(self):
"""
Assert that programs are output in id order
"""
for i in range(10):
ProgramFactory.create(live=True, title="Program {}".format(i + 1))
response = self.client.get("/")
content = response.content.decode('utf-8')
indexes = [content.find("Program {}".format(i + 1)) for i in range(10)]
assert indexes == sorted(indexes)
def setUpTestData(cls):
super().setUpTestData()
# create an user
cls.user = UserFactory.create()
cls.cached_edx_user_data = MagicMock(
spec=CachedEdxUserData,
enrollments=CachedEnrollment.deserialize_edx_data(cls.enrollments_json),
certificates=CachedCertificate.deserialize_edx_data(cls.certificates_json),
current_grades=CachedCurrentGrade.deserialize_edx_data(cls.current_grades_json),
)
# create the programs
cls.program = ProgramFactory.create(live=True, financial_aid_availability=False, price=1000)
cls.program_financial_aid = ProgramFactory.create(live=True, financial_aid_availability=True, price=1000)
# create course runs for the normal program
cls.course = CourseFactory.create(program=cls.program)
expected_course_keys = [
"course-v1:edX+DemoX+Demo_Course",
"course-v1:MITx+8.MechCX+2014_T1",
'',
None,
'course-v1:odl+FOO102+CR-FALL16'
]
cls.cruns = []
for course_key in expected_course_keys:
course_run = CourseRunFactory.create(
course=cls.course,
edx_course_key=course_key
)
if course_key:
cls.cruns.append(course_run)
# and the program with financial aid
finaid_course = CourseFactory.create(program=cls.program_financial_aid)
cls.now = now_in_utc()
cls.end_date = cls.now - timedelta(weeks=45)
cls.crun_fa = CourseRunFactory.create(
course=finaid_course,
start_date=cls.now-timedelta(weeks=52),
end_date=cls.end_date,
enrollment_start=cls.now-timedelta(weeks=62),
enrollment_end=cls.now-timedelta(weeks=53),
edx_course_key="course-v1:odl+FOO101+CR-FALL15"
)
cls.crun_fa2 = CourseRunFactory.create(
course=finaid_course
)
CourseRunFactory.create(
course=finaid_course,
edx_course_key=None
)
def setUpTestData(cls):
super().setUpTestData()
# create an user
cls.user = UserFactory.create()
cls.cached_edx_user_data = MagicMock(
spec=CachedEdxUserData,
enrollments=CachedEnrollment.deserialize_edx_data(cls.enrollments_json),
certificates=CachedCertificate.deserialize_edx_data(cls.certificates_json),
current_grades=CachedCurrentGrade.deserialize_edx_data(cls.current_grades_json),
)
# create the programs
cls.program = ProgramFactory.create(live=True, financial_aid_availability=False, price=1000)
cls.program_financial_aid = ProgramFactory.create(live=True, financial_aid_availability=True, price=1000)
# create course runs for the normal program
cls.course = CourseFactory.create(program=cls.program)
expected_course_keys = [
"course-v1:edX+DemoX+Demo_Course",
"course-v1:MITx+8.MechCX+2014_T1",
'',
None,
'course-v1:odl+FOO102+CR-FALL16'
]
cls.cruns = []
for course_key in expected_course_keys:
course_run = CourseRunFactory.create(
course=cls.course,
edx_course_key=course_key
)
if course_key:
cls.cruns.append(course_run)
# and the program with financial aid
finaid_course = CourseFactory.create(program=cls.program_financial_aid)
cls.now = now_in_utc()
cls.end_date = cls.now - timedelta(weeks=45)
cls.crun_fa = CourseRunFactory.create(
course=finaid_course,
start_date=cls.now-timedelta(weeks=52),
end_date=cls.end_date,
enrollment_start=cls.now-timedelta(weeks=62),
enrollment_end=cls.now-timedelta(weeks=53),
edx_course_key="course-v1:odl+FOO101+CR-FALL15"
)
cls.crun_fa2 = CourseRunFactory.create(
course=finaid_course
)
CourseRunFactory.create(
course=finaid_course,
edx_course_key=None
)
def test_unseed_db(self):
"""Test that unseed_db deletes seed data"""
for i in range(2):
ProgramFactory.create(description='{} test program {}'.format(FAKE_PROGRAM_DESC_PREFIX, i))
UserFactory.create(username='******'.format(FAKE_USER_USERNAME_PREFIX, i))
fake_program_qset = Program.objects.filter(description__startswith=FAKE_PROGRAM_DESC_PREFIX)
fake_user_qset = User.objects.filter(username__startswith=FAKE_USER_USERNAME_PREFIX)
assert fake_program_qset.count() == 2
assert fake_user_qset.count() == 2
unseed_db()
assert fake_program_qset.count() == 0
assert fake_user_qset.count() == 0
def test_program_page(self):
"""Verify that ProgramPage is passed in the context if and only if it's available"""
program_with_page = ProgramFactory.create(live=True)
program_page = ProgramPage(program=program_with_page, title="Test Program")
homepage = HomePage.objects.first()
homepage.add_child(instance=program_page)
program_page.save_revision().publish()
program_without_page = ProgramFactory.create(live=True)
response = self.client.get('/')
assert response.context['programs'] == [
(program_with_page, program_page),
(program_without_page, None),
]
def test_program_page(self):
"""Verify that ProgramPage is passed in the context if and only if it's available"""
program_with_page = ProgramFactory.create(live=True)
program_page = ProgramPage(program=program_with_page,
title="Test Program")
homepage = HomePage.objects.first()
homepage.add_child(instance=program_page)
program_page.save_revision().publish()
program_without_page = ProgramFactory.create(live=True)
response = self.client.get('/')
assert response.context['programs'] == [
(program_with_page, program_page),
(program_without_page, None),
]
def test_program_liveness(self):
"""Verify only 'live' program visible on homepage"""
program_live_true = ProgramFactory.create(live=True)
program_live_false = ProgramFactory.create(live=False)
response = self.client.get('/')
self.assertContains(
response,
program_live_true.description,
status_code=200
)
self.assertNotContains(
response,
program_live_false.description,
status_code=200
)
def setUpTestData(cls):
super().setUpTestData()
with mute_signals(post_save):
staff_profile = ProfileFactory.create(user__email='*****@*****.**')
recipient_profile = ProfileFactory.create(
user__email='*****@*****.**',
email_optin=True,
)
cls.staff_user = staff_profile.user
cls.recipient_user = recipient_profile.user
cls.program = ProgramFactory.create(financial_aid_availability=False)
ProgramEnrollmentFactory.create(
user=cls.recipient_user,
program=cls.program
)
Role.objects.create(
user=cls.staff_user,
program=cls.program,
role=Staff.ROLE_ID
)
cls.url_name = 'learner_mail_api'
cls.request_data = {
'email_subject': 'email subject',
'email_body': 'email body'
}
def test_staff_sees_entire_profile(self):
"""
Staff should be able to see the entire profile despite the account privacy
"""
with mute_signals(post_save):
profile = ProfileFactory.create(user=self.user2,
account_privacy=Profile.PRIVATE)
ProfileFactory.create(user=self.user1,
verified_micromaster_user=False)
program = ProgramFactory.create()
ProgramEnrollment.objects.create(
program=program,
user=profile.user,
)
Role.objects.create(
program=program,
role=Staff.ROLE_ID,
user=self.user1,
)
self.client.force_login(self.user1)
resp = self.client.get(self.url2)
profile_data = ProfileSerializer(profile).data
assert resp.json() == format_image_expectation(profile_data)
def setUp(self):
super(TestProgramPage, self).setUp()
homepage = HomePage.objects.first()
program = ProgramFactory.create(title="Test Program Title", live=True)
self.program_page = ProgramPage(program=program, title="Test Program")
homepage.add_child(instance=self.program_page)
self.program_page.save_revision().publish()
def setUp(self):
super(TestProgramPage, self).setUp()
homepage = HomePage.objects.first()
program = ProgramFactory.create(title="Test Program Title", live=True)
self.program_page = ProgramPage(program=program, title="Test Program")
homepage.add_child(instance=self.program_page)
self.program_page.save_revision().publish()
def test_roles_setting(self):
"""
Assert SETTINGS when a user has roles assigned to them
"""
profile = self.create_and_login_user()
Role.objects.create(
program=ProgramFactory.create(),
user=profile.user,
role=Role.DEFAULT_ROLE,
)
resp = self.client.get(DASHBOARD_URL)
js_settings = json.loads(resp.context['js_settings_json'])
assert js_settings['roles'] == [{
'program':
role.program.id,
'role':
role.role,
'permissions': [
key
for key, value in available_perm_status(profile.user).items()
if value is True
],
} for role in profile.user.role_set.all()]
def test_index_context_logged_in_staff(self, role):
"""
Assert context values when logged in as staff for a program
"""
program = ProgramFactory.create(live=True)
with mute_signals(post_save):
profile = ProfileFactory.create()
Role.objects.create(
role=role,
program=program,
user=profile.user,
)
self.client.force_login(profile.user)
ga_tracking_id = FuzzyText().fuzz()
with self.settings(GA_TRACKING_ID=ga_tracking_id, ):
response = self.client.get('/')
assert response.context['authenticated'] is True
assert response.context['username'] is None
assert response.context['title'] == HomePage.objects.first().title
assert response.context['is_public'] is True
assert response.context['has_zendesk_widget'] is True
assert response.context['is_staff'] is True
assert response.context['programs'] == [
(program, None),
]
self.assertContains(response, 'Share this page')
js_settings = json.loads(response.context['js_settings_json'])
assert js_settings['gaTrackingID'] == ga_tracking_id
def base_test_data():
"""
Fixture for test data that should be available to any test case in the suite
"""
# Create a live program with valid prices and financial aid
program = ProgramFactory.create(
live=True,
financial_aid_availability=True,
price=1000,
)
CourseRunFactory.create(course__program=program)
TierProgramFactory.create_properly_configured_batch(2, program=program)
# Create users
staff_user, student_user = (create_user_for_login(is_staff=True), create_user_for_login(is_staff=False))
ProgramEnrollment.objects.create(program=program, user=staff_user)
ProgramEnrollment.objects.create(program=program, user=student_user)
Role.objects.create(
role=Staff.ROLE_ID,
user=staff_user,
program=program,
)
return SimpleNamespace(
staff_user=staff_user,
student_user=student_user,
program=program
)
def test_switch_program(self, browser, base_test_data, logged_in_staff):
"""
Switching programs should show a different set of users
"""
existing_program_user_count = settings.ELASTICSEARCH_DEFAULT_PAGE_SIZE
create_enrolled_user_batch(existing_program_user_count, program=base_test_data.program, is_staff=False)
new_program = ProgramFactory.create(live=True)
new_program_user_count = settings.ELASTICSEARCH_DEFAULT_PAGE_SIZE - 1
create_enrolled_user_batch(new_program_user_count, program=new_program, is_staff=False)
ProgramEnrollment.objects.create(program=new_program, user=logged_in_staff)
Role.objects.create(
role=Staff.ROLE_ID,
user=logged_in_staff,
program=new_program,
)
# Load the learners page for the existing program
browser.get("/learners")
browser.wait_until_element_count(By.CLASS_NAME, 'learner-result', existing_program_user_count)
# Switch programs and check that the correct number of users are returned
switcher = browser.driver.find_element_by_css_selector('.micromasters-header .Select-input')
switcher.send_keys(Keys.DOWN)
switcher.send_keys(Keys.ENTER)
browser.wait_until_element_count(By.CLASS_NAME, 'learner-result', new_program_user_count)
# Refresh browser and verify the count is the same
browser.get("/learners")
browser.wait_until_element_count(By.CLASS_NAME, 'learner-result', new_program_user_count)
def test_serialize_basket_product_version_program(mock_context):
"""Test ProductVersion serialization for a Program"""
program = ProgramFactory.create()
courses = CourseFactory.create_batch(3, program=program)
product_version = ProductVersionFactory.create(
product=ProductFactory(content_object=program)
)
data = FullProductVersionSerializer(
instance=product_version, context=mock_context
).data
assert data == {
"id": product_version.id,
"description": product_version.description,
"content_title": product_version.product.content_object.title,
"price": str(round_half_up(product_version.price)),
"type": product_version.product.content_type.model,
"courses": [
CourseSerializer(instance=course, context=mock_context).data
for course in courses
],
"thumbnail_url": program.catalog_image_url,
"object_id": product_version.product.object_id,
"product_id": product_version.product.id,
"readable_id": get_readable_id(product_version.product.content_object),
"run_tag": None,
"created_on": product_version.created_on.strftime(datetime_millis_format),
"start_date": product_version.product.content_object.next_run_date.isoformat()
if product_version.product.content_object.next_run_date
else None,
}
def test_program_enrolled_user_serializer(self): # pylint: disable=no-self-use
"""
Asserts the output of the serializer for program-enrolled users (ProgramEnrollments)
"""
with mute_signals(post_save):
profile = ProfileFactory.create()
EducationFactory.create(profile=profile)
EmploymentFactory.create(profile=profile)
program = ProgramFactory.create()
course = CourseFactory.create(program=program)
course_runs = [
CourseRunFactory.create(course=course) for _ in range(2)
]
for course_run in course_runs:
CachedCertificateFactory.create(user=profile.user,
course_run=course_run)
CachedEnrollmentFactory.create(user=profile.user,
course_run=course_run)
program_enrollment = ProgramEnrollment.objects.create(
user=profile.user, program=program)
assert serialize_program_enrolled_user(program_enrollment) == {
'_id': program_enrollment.id,
'id': program_enrollment.id,
'user_id': profile.user.id,
'email': profile.user.email,
'profile': ProfileSerializer().to_representation(profile),
'program': UserProgramSerializer.serialize(program_enrollment)
}
def test_unseed_db(self):
"""Test that unseed_db deletes seed data"""
for i in range(2):
ProgramFactory.create(description='{} test program {}'.format(
FAKE_PROGRAM_DESC_PREFIX, i))
UserFactory.create(username='******'.format(
FAKE_USER_USERNAME_PREFIX, i))
fake_program_qset = Program.objects.filter(
description__startswith=FAKE_PROGRAM_DESC_PREFIX)
fake_user_qset = User.objects.filter(
username__startswith=FAKE_USER_USERNAME_PREFIX)
assert fake_program_qset.count() == 2
assert fake_user_qset.count() == 2
unseed_db()
assert fake_program_qset.count() == 0
assert fake_user_qset.count() == 0
def setUpTestData(cls):
with mute_signals(post_save):
cls.profile = ProfileFactory.create()
cls.program = ProgramFactory.create(financial_aid_availability=True)
cls.tiers = {
"0k":
TierProgramFactory.create(program=cls.program,
income_threshold=0,
current=True),
"15k":
TierProgramFactory.create(program=cls.program,
income_threshold=15000,
current=True),
"50k":
TierProgramFactory.create(program=cls.program,
income_threshold=50000,
current=True),
"100k":
TierProgramFactory.create(program=cls.program,
income_threshold=100000,
current=True),
"150k_not_current":
TierProgramFactory.create(program=cls.program,
income_threshold=150000,
current=False)
}
cls.program_enrollment = ProgramEnrollment.objects.create(
user=cls.profile.user, program=cls.program)
def setUpTestData(cls):
super().setUpTestData()
with mute_signals(post_save):
cls.user = ProfileFactory.create().user
cls.program = ProgramFactory.create()
cls.course = CourseFactory.create(program=cls.program)
def test_program_certificate_start_end_dates(user):
"""
Test that the ProgramCertificate start_end_dates property works properly
"""
now = now_in_utc()
start_date = now + timedelta(days=1)
end_date = now + timedelta(days=100)
program = ProgramFactory.create()
early_course_run = CourseRunFactory.create(course__program=program,
start_date=start_date,
end_date=end_date)
later_course_run = CourseRunFactory.create(
course__program=program,
start_date=start_date + timedelta(days=1),
end_date=end_date + timedelta(days=1),
)
# Need the course run certificates to be there in order for the start_end_dates
# to return valid values
CourseRunCertificateFactory.create(course_run=early_course_run, user=user)
CourseRunCertificateFactory.create(course_run=later_course_run, user=user)
certificate = ProgramCertificateFactory.create(program=program, user=user)
program_start_date, program_end_date = certificate.start_end_dates
assert program_start_date == early_course_run.start_date
assert program_end_date == later_course_run.end_date
def setUpTestData(cls):
"""Create a program and user to test with"""
super().setUpTestData()
cls.program = ProgramFactory.create()
cls.user = UserFactory.create()
cls.context = {"request": Mock(user=cls.user)}
def test_index_context_logged_in_staff(self, role):
"""
Assert context values when logged in as staff for a program
"""
program = ProgramFactory.create(live=True)
with mute_signals(post_save):
profile = ProfileFactory.create()
Role.objects.create(
role=role,
program=program,
user=profile.user,
)
self.client.force_login(profile.user)
ga_tracking_id = FuzzyText().fuzz()
with self.settings(
GA_TRACKING_ID=ga_tracking_id,
):
response = self.client.get('/')
assert response.context['authenticated'] is True
assert response.context['username'] is None
assert response.context['title'] == HomePage.objects.first().title
assert response.context['is_public'] is True
assert response.context['has_zendesk_widget'] is True
assert response.context['is_staff'] is True
assert response.context['programs'] == [
(program, None),
]
self.assertContains(response, 'Share this page')
js_settings = json.loads(response.context['js_settings_json'])
assert js_settings['gaTrackingID'] == ga_tracking_id
def test_course_tier_mandatory(self):
"""
Test that an attempt to serialize financial aid information will raise an exception if no tiers are created.
"""
new_program = ProgramFactory.create(live=True, financial_aid_availability=True, price=1000)
with self.assertRaises(ImproperlyConfigured):
FinancialAidDashboardSerializer.serialize(self.user, new_program)
def setUpTestData(cls):
with mute_signals(post_save):
profile = ProfileFactory.create()
cls.user = profile.user
cls.program = ProgramFactory.create()
cls.program_enrollment = ProgramEnrollment.objects.create(
user=cls.user, program=cls.program)
def base_test_data():
"""
Fixture for test data that should be available to any test case in the suite
"""
# Create a live program with valid prices and financial aid
program = ProgramFactory.create(
live=True,
financial_aid_availability=True,
price=1000,
)
CourseRunFactory.create(course__program=program)
TierProgramFactory.create_properly_configured_batch(2, program=program)
# Create users
staff_user, student_user = (create_user_for_login(is_staff=True),
create_user_for_login(is_staff=False))
ProgramEnrollment.objects.create(program=program, user=staff_user)
ProgramEnrollment.objects.create(program=program, user=student_user)
Role.objects.create(
role=Staff.ROLE_ID,
user=staff_user,
program=program,
)
return SimpleNamespace(staff_user=staff_user,
student_user=student_user,
program=program)
def test_catalog_program_serializer(has_page, has_thumbnail):
"""Tests that the catalog serializer returns a correct data structure"""
page = ProgramPageFactory.create(
has_thumbnail=has_thumbnail) if has_page else None
program = page.program if page else ProgramFactory.create()
courses = CourseFactory.create_batch(3, program=program)
for course in courses:
CourseRunFactory.create_batch(2, course=course)
faculty_name = "faculty"
if has_page:
ProgramFaculty.objects.create(
program_page=page,
name=faculty_name,
)
serialized = CatalogProgramSerializer(program).data
# coerce OrderedDict objects to dict
serialized = {
**serialized, "courses": [{
**course, "course_runs":
[dict(run) for run in course["course_runs"]]
} for course in serialized["courses"]]
}
assert serialized == {
"id":
program.id,
"title":
program.title,
"programpage_url":
page.get_full_url() if has_page else None,
"thumbnail_url":
(page.thumbnail_image.get_rendition('fill-300x186').url
if has_page and has_thumbnail else None),
"courses": [{
"id":
course.id,
"edx_key":
course.edx_key,
"position_in_program":
course.position_in_program,
"course_runs": [{
"id": course_run.id,
"edx_course_key": course_run.edx_course_key,
} for course_run in course.courserun_set.all()]
} for course in courses],
'topics': [{
'name': topic.name
} for topic in program.topics.iterator()],
"instructors": [{
"name": faculty_name
}] if has_page else [],
"start_date":
courses[0].first_unexpired_run().start_date,
"enrollment_start":
courses[0].first_unexpired_run().enrollment_start,
"end_date":
courses[-1].courserun_set.last().end_date,
"total_price":
str(program.price * program.num_required_courses),
}
def test_lists_live_programs(self):
"""Live programs should show up"""
prog = ProgramFactory.create(live=True)
resp = self.client.get(reverse('program-list'))
assert len(resp.json()) == 1
assert prog.title == resp.json()[0]['title']
def test_determine_tier_program_improper_setup(self):
"""
Tests that determine_tier_program() raises ImproperlyConfigured if no $0-discount TierProgram
has been created and income supplied is too low.
"""
program = ProgramFactory.create()
with self.assertRaises(ImproperlyConfigured):
determine_tier_program(program, 0)
def test_program_page():
"""
page property should return an associated Wagtail page if one exists
"""
program = ProgramFactory.create(page=None)
assert program.page is None
page = ProgramPageFactory.create(program=program)
assert program.page == page
def setUpTestData(cls):
super(ProgramLearnersTests, cls).setUpTestData()
cls.program = ProgramFactory.create(live=True)
cls.url = reverse('learners_in_program',
kwargs={"program_id": cls.program.id})
cls.user = create_learner_with_image(privacy=Profile.PUBLIC)
def test_create_program_not_live(self):
"""Test in case the program is not live"""
program = ProgramFactory.create(live=False)
self.assert_program_enrollments_count()
resp = self.client.post(self.url, {'program_id': program.pk},
format='json')
self.assert_program_enrollments_count()
assert resp.status_code == status.HTTP_404_NOT_FOUND
def test_determine_tier_program_improper_setup(self):
"""
Tests that determine_tier_program() raises ImproperlyConfigured if no $0-discount TierProgram
has been created and income supplied is too low.
"""
program = ProgramFactory.create()
with self.assertRaises(ImproperlyConfigured):
determine_tier_program(program, 0)
def test_deserialize_course_data(self):
"""Test that course data is correctly deserialized"""
new_program = ProgramFactory.create()
new_course = deserialize_course_data(new_program, self.COURSE_DATA)
new_course_runs = new_course.courserun_set.all()
assert new_course.title == 'Digital Learning 100'
assert len(new_course_runs) == 1
assert new_course_runs[0].title == 'Digital Learning 100 - January 2016'
def test_with_non_financial_aid_program(self):
"""
Test that a non-financial aid program will serialize to an empty dict
"""
non_fa_program = ProgramFactory.create(
live=True, financial_aid_availability=False)
assert FinancialAidDashboardSerializer.serialize(
self.user, non_fa_program) == {}
def test_programs_not_live(client, live):
"""Programs should be filtered out if live=False"""
program = ProgramFactory.create(live=live)
ProductVersionFactory.create(product=ProductFactory(
content_object=program))
resp = client.get(reverse("programs_api-list"))
assert resp.status_code == status.HTTP_200_OK
assert_drf_json_equal(resp.json(),
[ProgramSerializer(program).data] if live else [])
def setUpTestData(cls):
"""Create a program and user to test with"""
super().setUpTestData()
cls.program = ProgramFactory.create()
cls.user = UserFactory.create()
cls.context = {
"request": Mock(user=cls.user)
}
def setUpTestData(cls):
cls.staff_user = UserFactory.create()
cls.program = ProgramFactory.create()
Role.objects.create(
user=cls.staff_user,
program=cls.program,
role=Staff.ROLE_ID,
)
cls.url = reverse('automatic_email_api-list')
def setUpTestData(cls):
with mute_signals(post_save):
cls.profile = profile = ProfileFactory.create()
cls.user = profile.user
# Create non-FA program data
cls.non_fa_program = ProgramFactory.create()
_, course_runs = cls.generate_course_with_runs(
cls.non_fa_program,
course_params=dict(title='Non FA Course 1')
)
cls.non_fa_enrollments = [cls.verified_enroll(cls.user, course_runs[0])]
cls.non_fa_program_enrollment = ProgramEnrollment.objects.create(user=cls.user, program=cls.non_fa_program)
# Create FA program data
cls.fa_program = ProgramFactory.create(financial_aid_availability=False)
_, course_runs = cls.generate_course_with_runs(
cls.fa_program,
course_params=dict(title='FA Course 1')
)
cls.fa_enrollments = [cls.verified_enroll(cls.user, course_runs[0])]
cls.fa_program_enrollment = ProgramEnrollment.objects.create(user=cls.user, program=cls.fa_program)
def setUpTestData(cls):
super(DashboardTest, cls).setUpTestData()
# create a user
cls.user = SocialUserFactory.create()
UserCacheRefreshTimeFactory(user=cls.user, unexpired=True)
# create the programs
cls.program_1 = ProgramFactory.create(live=True)
cls.program_2 = ProgramFactory.create(live=True)
cls.program_not_enrolled = ProgramFactory.create(live=True)
cls.program_no_live = ProgramFactory.create(live=False)
# enroll the user in some courses
for program in [cls.program_1, cls.program_2, cls.program_no_live]:
ProgramEnrollment.objects.create(
user=cls.user,
program=program
)
# url for the dashboard
cls.url = reverse('dashboard_api', args=[cls.user.social_auth.first().uid])
def setUpTestData(cls):
cls.search_result_mail_url = reverse('search_result_mail_api')
cls.program = ProgramFactory.create(live=True)
# create a user with a role for one program
with mute_signals(post_save):
staff_profile = ProfileFactory.create()
cls.staff = staff_profile.user
Role.objects.create(
user=cls.staff,
program=cls.program,
role=Staff.ROLE_ID
)
def setUpTestData(cls):
with mute_signals(post_save):
cls.profile = ProfileFactory.create()
EducationFactory.create(profile=cls.profile)
EmploymentFactory.create(profile=cls.profile)
EmploymentFactory.create(profile=cls.profile, end_date=None)
program = ProgramFactory.create()
course = CourseFactory.create(program=program)
course_runs = [CourseRunFactory.create(course=course) for _ in range(2)]
for course_run in course_runs:
CachedCertificateFactory.create(user=cls.profile.user, course_run=course_run)
CachedEnrollmentFactory.create(user=cls.profile.user, course_run=course_run)
cls.program_enrollment = ProgramEnrollment.objects.create(user=cls.profile.user, program=program)
def create(cls, **kwargs):
"""
Overrides default ProgramEnrollment object creation for the factory.
"""
user = kwargs.get('user', UserFactory.create())
program = kwargs.get('program', ProgramFactory.create())
course = CourseFactory.create(program=program)
course_run = CourseRunFactory.create(course=course)
CachedEnrollmentFactory.create(user=user, course_run=course_run)
CachedCertificateFactory.create(user=user, course_run=course_run)
CachedCurrentGradeFactory.create(user=user, course_run=course_run)
program_enrollment = ProgramEnrollment.objects.create(user=user, program=program)
return program_enrollment
def test_login_redirect_learners(self):
"""
Staff or instructors should be directed to /learners
"""
for role in [Staff.ROLE_ID, Instructor.ROLE_ID]:
user = UserFactory.create()
Role.objects.create(user=user, role=role, program=ProgramFactory.create())
mock_strategy = mock.Mock()
mock_strategy.session.load.return_value = {}
mock_strategy.session.get.return_value = {}
backend = edxorg.EdxOrgOAuth2(strategy=mock_strategy)
pipeline_api.update_profile_from_edx(backend, user, {}, False, **{'edx_profile': self.mocked_edx_profile})
mock_strategy.session_set.assert_called_with('next', '/learners')
def setUpTestData(cls):
super().setUpTestData()
cls.user = UserFactory.create()
cls.program = ProgramFactory.create(live=True, financial_aid_availability=True, price=1000)
cls.min_tier_program = TierProgramFactory.create(
program=cls.program,
discount_amount=750,
current=True
)
cls.max_tier_program = TierProgramFactory.create(
program=cls.program,
discount_amount=0,
current=True
)
def test_program_link(self):
"""Verify that program links are present in home page if ProgramPage is set"""
program = ProgramFactory.create(live=True)
program_page = ProgramPage(program=program, title="Test Program")
homepage = HomePage.objects.first()
homepage.add_child(instance=program_page)
program_page.save_revision().publish()
response = self.client.get('/')
self.assertContains(
response,
program_page.url,
status_code=200
)
def test_course_finder_success(self):
"""Tests that CourseFinder will return a desired course"""
program = ProgramFactory.create(title='program1')
course = CourseFactory.create(title='Course Lvl 100', program=program)
CourseFactory.create(title='Course Lvl 200', program=program)
CourseFactory.create(title='Course Lvl 300', program=program)
CourseFactory.create(title='Other Course 100', program__title='program2')
found_courses = [
CourseFinder.find(course_title='Course Lvl 100'),
CourseFinder.find(course_title='Lvl 100'),
CourseFinder.find(program_title='program1', course_level='100')
]
assert all([course == found_course for found_course in found_courses])
def test_other_programs_not_serialized(self):
"""
Tests that the serialization for a ProgramEnrollment doesn't yield enrollment data for a different program
"""
program_enrollment_to_test = self.non_fa_program_enrollment
# We want to test serialization for a new course in the enrolled program and a different program
programs_to_test = [program_enrollment_to_test.program, ProgramFactory.create()]
for program in programs_to_test:
course, course_runs = self.generate_course_with_runs(program)
self.verified_enroll(self.user, course_run=course_runs[0])
serialized_program_user = UserProgramSearchSerializer.serialize(program_enrollment_to_test)
# If the new course's program is the same one we just serialized, we expect the course to be serialized.
course_is_expected_serialized = program == program_enrollment_to_test.program
course_is_serialized = self.is_course_serialized(serialized_program_user['courses'], course)
assert course_is_serialized == course_is_expected_serialized
def test_can_view_if_verified_mm_user(self):
"""
Verified MM users are allowed to view public_to_mm profile.
"""
new_user = SocialProfileFactory.create(account_privacy=Profile.PUBLIC_TO_MM).user
verified_user = SocialProfileFactory.create(verified_micromaster_user=True).user
program = ProgramFactory.create()
for user in [new_user, verified_user]:
ProgramEnrollment.objects.create(
program=program,
user=user,
)
request = Mock(user=verified_user)
view = Mock(kwargs={'user': self.get_social_auth_uid(new_user)})
assert self.perm.has_permission(request, view) is True
def test_has_paid_for_any_in_program(self):
"""
Assert that has_paid_for_any_in_program returns True if any CourseRun associated with a Program has been
paid for.
"""
new_program = ProgramFactory.create()
new_course_runs = CourseRunFactory.create_batch(2, course__program=new_program)
mmtrack = MMTrack(
user=self.user,
program=new_program,
edx_user_data=self.cached_edx_user_data
)
assert mmtrack.has_paid_for_any_in_program() is False
fg = FinalGradeFactory.create(user=self.user, course_run=new_course_runs[0], course_run_paid_on_edx=True)
assert mmtrack.has_paid_for_any_in_program() is True
fg.delete()
FinalGradeFactory.create(user=self.user, course_run=new_course_runs[1], course_run_paid_on_edx=True)
assert mmtrack.has_paid_for_any_in_program() is True
