def test_queryset_method_returns_all_programs(self):
""" Verify that all programs pass the filter. """
verified_seat_type = factories.SeatTypeFactory.verified()
program_type = factories.ProgramTypeFactory(
applicable_seat_types=[verified_seat_type])
program_filter = ProgramEligibilityFilter(None, {}, None, None)
course_run = factories.CourseRunFactory()
factories.SeatFactory(course_run=course_run,
type=verified_seat_type,
upgrade_deadline=None)
one_click_purchase_eligible_program = factories.ProgramFactory(
type=program_type,
courses=[course_run.course],
one_click_purchase_enabled=True)
one_click_purchase_ineligible_program = factories.ProgramFactory(
courses=[course_run.course])
with self.assertNumQueries(1):
self.assertEqual(
list(program_filter.queryset({}, Program.objects.all())), [
one_click_purchase_ineligible_program,
one_click_purchase_eligible_program
])
def test_normal_case(self):
"""
Test the case where we have a random mix of creates and updates to several
different CourseRun records.
"""
# Induce a few history records:
# - 2 updates for courserun1
# - 0 updates for courserun2
# - 3 updates for courserun3
self.courserun1.save()
self.courserun3.save()
self.courserun1.save()
self.courserun3.save()
factories.CourseRunFactory() # Toss in a fourth create to mix things up.
self.courserun3.save()
courserun1_count_initial = len(CourseRun.history.filter(id=self.courserun1.id).all()) # pylint: disable=no-member
courserun2_count_initial = len(CourseRun.history.filter(id=self.courserun2.id).all()) # pylint: disable=no-member
courserun3_count_initial = len(CourseRun.history.filter(id=self.courserun3.id).all()) # pylint: disable=no-member
# Ensure that there are multiple history records for each course run. For each
# course run, there should be 2 (baseline) + the amount we added at the
# beginning of this test.
assert courserun1_count_initial == (2 + 2)
assert courserun2_count_initial == (2 + 0)
assert courserun3_count_initial == (2 + 3)
self.run_command('course_metadata.CourseRun')
courserun1_count_final = len(CourseRun.history.filter(id=self.courserun1.id).all()) # pylint: disable=no-member
courserun2_count_final = len(CourseRun.history.filter(id=self.courserun2.id).all()) # pylint: disable=no-member
courserun3_count_final = len(CourseRun.history.filter(id=self.courserun3.id).all()) # pylint: disable=no-member
# Ensure that the only history records left are the 3 original creates.
assert courserun1_count_final == 1
assert courserun2_count_final == 1
assert courserun3_count_final == 1
def create_program_with_seats(self):
currency = Currency.objects.get(code='USD')
course_run = factories.CourseRunFactory()
factories.SeatFactory(type='audit',
currency=currency,
course_run=course_run,
price=0)
factories.SeatFactory(type='credit',
currency=currency,
course_run=course_run,
price=600)
factories.SeatFactory(type='verified',
currency=currency,
course_run=course_run,
price=100)
applicable_seat_types = SeatType.objects.filter(
slug__in=['credit', 'verified'])
program_type = factories.ProgramTypeFactory(
applicable_seat_types=applicable_seat_types)
return factories.ProgramFactory(type=program_type,
courses=[course_run.course])
def test_queryset_method_returns_eligible_programs(self):
""" Verify that one click purchase eligible programs pass the filter. """
verified_seat_type = factories.SeatTypeFactory.verified()
program_type = factories.ProgramTypeFactory(
applicable_seat_types=[verified_seat_type])
program_filter = ProgramEligibilityFilter(None,
{self.parameter_name: 1},
None, None)
course_run = factories.CourseRunFactory(
end=None,
enrollment_end=None,
)
factories.SeatFactory(course_run=course_run,
type=verified_seat_type,
upgrade_deadline=None)
one_click_purchase_eligible_program = factories.ProgramFactory(
type=program_type,
courses=[course_run.course],
one_click_purchase_enabled=True,
)
with self.assertNumQueries(FuzzyInt(11, 2)):
self.assertEqual(
list(program_filter.queryset({}, Program.objects.all())),
[one_click_purchase_eligible_program])
def assert_one_click_purchase_ineligible_program(
self,
end=None,
enrollment_start=None,
enrollment_end=None,
seat_type=Seat.VERIFIED,
upgrade_deadline=None,
one_click_purchase_enabled=True,
excluded_course_runs=None,
program_type=None):
course_run = factories.CourseRunFactory(
end=end,
enrollment_start=enrollment_start,
enrollment_end=enrollment_end)
factories.SeatFactory(course_run=course_run,
type=seat_type,
upgrade_deadline=upgrade_deadline)
program = factories.ProgramFactory(
courses=[course_run.course],
excluded_course_runs=excluded_course_runs,
one_click_purchase_enabled=one_click_purchase_enabled,
type=program_type,
)
self.assertFalse(program.is_program_eligible_for_one_click_purchase)
def setUp(self):
super(CourseSocialNetworkTests, self).setUp()
self.network = factories.CourseRunSocialNetworkFactory()
self.course_run = factories.CourseRunFactory()
def setUp(self):
super(CourseRunTests, self).setUp()
self.course_run = factories.CourseRunFactory()
def test_nondraft_does_not_collide_with_draft(self):
with self.assertNumQueries(80, threshold=0):
factories.CourseRunFactory(course=self.course_1,
draft=False,
external_key='external-key-drafttest')
def setUp(self):
super().setUp()
# Disable marketing site password just to save us from having to mock the responses
self.partner = factories.PartnerFactory(
marketing_site_api_password=None)
# Fill out a bunch of types and modes. Exact mode parameters don't matter, just the resulting seat types.
self.audit_seat_type = factories.SeatTypeFactory.audit()
self.verified_seat_type = factories.SeatTypeFactory.verified()
self.audit_mode = Mode.objects.get(slug=Seat.AUDIT)
self.verified_mode = Mode.objects.get(slug=Seat.VERIFIED)
self.audit_track = Track.objects.get(seat_type=self.audit_seat_type,
mode=self.audit_mode)
self.verified_track = Track.objects.get(
seat_type=self.verified_seat_type, mode=self.verified_mode)
self.empty_run_type = CourseRunType.objects.get(
slug=CourseRunType.EMPTY)
self.audit_run_type = CourseRunType.objects.get(
slug=CourseRunType.AUDIT)
self.va_run_type = CourseRunType.objects.get(
slug=CourseRunType.VERIFIED_AUDIT)
self.empty_course_type = CourseType.objects.get(slug=CourseType.EMPTY)
self.va_course_type = CourseType.objects.get(
slug=CourseType.VERIFIED_AUDIT)
self.audit_course_type = CourseType.objects.get(slug=CourseType.AUDIT)
# Now create some courses and orgs that will be found to match the above, in the simple happy path case.
self.org = factories.OrganizationFactory(partner=self.partner,
key='Org1')
self.course = factories.CourseFactory(
partner=self.partner,
authoring_organizations=[self.org],
type=self.empty_course_type,
key='{org}+Course1'.format(org=self.org.key))
self.entitlement = factories.CourseEntitlementFactory(
partner=self.partner,
course=self.course,
mode=self.verified_seat_type)
self.audit_run = factories.CourseRunFactory(
course=self.course,
type=self.empty_run_type,
key='course-v1:Org1+Course1+A')
self.audit_seat = factories.SeatFactory(course_run=self.audit_run,
type=self.audit_seat_type)
self.verified_run = factories.CourseRunFactory(
course=self.course,
type=self.empty_run_type,
key='course-v1:Org1+Course1+V')
self.verified_seat = factories.SeatFactory(
course_run=self.verified_run, type=self.verified_seat_type)
self.verified_audit_seat = factories.SeatFactory(
course_run=self.verified_run, type=self.audit_seat_type)
# Create parallel obj / course for argument testing
self.org2 = factories.OrganizationFactory(partner=self.partner,
key='Org2')
self.org3 = factories.OrganizationFactory(partner=self.partner,
key='Org3')
self.course2 = factories.CourseFactory(
partner=self.partner,
authoring_organizations=[self.org2, self.org3],
type=self.empty_course_type,
key='{org}+Course1'.format(org=self.org2.key))
self.c2_audit_run = factories.CourseRunFactory(
course=self.course2, type=self.empty_run_type)
self.c2_audit_seat = factories.SeatFactory(
course_run=self.c2_audit_run, type=self.audit_seat_type)
def setUp(self):
super().setUp()
self.courserun1 = factories.CourseRunFactory(draft=False)
self.courserun2 = factories.CourseRunFactory(draft=False)
self.courserun3 = factories.CourseRunFactory(draft=True)
def test_one_click_purchase_ineligible(self):
""" Verify that program is one click purchase ineligible. """
yesterday = datetime.datetime.utcnow() - datetime.timedelta(days=1)
tomorrow = datetime.datetime.utcnow() + datetime.timedelta(days=1)
verified_seat_type, __ = SeatType.objects.get_or_create(
name=Seat.VERIFIED)
program_type = factories.ProgramTypeFactory(
applicable_seat_types=[verified_seat_type])
# Program has one_click_purchase_enabled set to False and
# every course has one course run
self.assert_one_click_purchase_ineligible_program(
one_click_purchase_enabled=False,
program_type=program_type,
)
# Program has one_click_purchase_enabled set to True and
# one course has two course runs
course_run = factories.CourseRunFactory(end=None, enrollment_end=None)
factories.CourseRunFactory(end=None,
enrollment_end=None,
course=course_run.course)
factories.SeatFactory(course_run=course_run,
type='verified',
upgrade_deadline=None)
program = factories.ProgramFactory(
courses=[course_run.course],
one_click_purchase_enabled=True,
type=program_type,
)
self.assertFalse(program.is_program_eligible_for_one_click_purchase)
# Program has one_click_purchase_enabled set to True and
# one course with one course run excluded from the program
course_run = factories.CourseRunFactory(end=None, enrollment_end=None)
factories.SeatFactory(course_run=course_run,
type='verified',
upgrade_deadline=None)
program = factories.ProgramFactory(
courses=[course_run.course],
one_click_purchase_enabled=True,
excluded_course_runs=[course_run],
type=program_type,
)
self.assertFalse(program.is_program_eligible_for_one_click_purchase)
# Program has one_click_purchase_enabled set to True, one course
# with one course run, course run end date passed
self.assert_one_click_purchase_ineligible_program(
end=yesterday,
program_type=program_type,
)
# Program has one_click_purchase_enabled set to True, one course
# with one course run, course run enrollment start date not passed
self.assert_one_click_purchase_ineligible_program(
enrollment_start=tomorrow,
program_type=program_type,
)
# Program has one_click_purchase_enabled set to True, one course
# with one course run, course run enrollment end date passed
self.assert_one_click_purchase_ineligible_program(
enrollment_end=yesterday,
program_type=program_type,
)
# Program has one_click_purchase_enabled set to True, one course
# with one course run, seat upgrade deadline passed
self.assert_one_click_purchase_ineligible_program(
upgrade_deadline=yesterday,
program_type=program_type,
)
# Program has one_click_purchase_enabled set to True, one course
# with one course run, seat type is not purchasable
self.assert_one_click_purchase_ineligible_program(
seat_type='incorrect',
program_type=program_type,
)
