def test_queryset_method_returns_eligible_programs(self):
""" Verify that one click purchase eligible programs pass the filter. """
verified_seat_type, __ = SeatType.objects.get_or_create(
name=Seat.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',
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(12):
self.assertEqual(
list(program_filter.queryset({}, Program.objects.all())),
[one_click_purchase_eligible_program])
def test_price_ranges_multiple_course(self):
""" Verifies the price_range property of a program with multiple courses """
currency = Currency.objects.get(code='USD')
test_price = 100
for course_run in self.course_runs:
factories.SeatFactory(type='audit',
currency=currency,
course_run=course_run,
price=0)
factories.SeatFactory(type='verified',
currency=currency,
course_run=course_run,
price=test_price)
test_price += 100
applicable_seat_types = SeatType.objects.filter(slug__in=['verified'])
program_type = factories.ProgramTypeFactory(
applicable_seat_types=applicable_seat_types)
self.program.type = program_type
expected_price_ranges = [{
'currency': 'USD',
'min': Decimal(100),
'max': Decimal(300),
'total': Decimal(600)
}]
self.assertEqual(self.program.price_ranges, expected_price_ranges)
def test_one_click_purchase_eligible_with_unpublished_runs(self):
""" Verify that program with unpublished course runs is one click purchase eligible. """
verified_seat_type, __ = SeatType.objects.get_or_create(
name=Seat.VERIFIED)
program_type = factories.ProgramTypeFactory(
applicable_seat_types=[verified_seat_type])
published_course_run = factories.CourseRunFactory(
end=None, enrollment_end=None, status=CourseRunStatus.Published)
unpublished_course_run = factories.CourseRunFactory(
end=None,
enrollment_end=None,
status=CourseRunStatus.Unpublished,
course=published_course_run.course)
factories.SeatFactory(course_run=published_course_run,
type=Seat.VERIFIED,
upgrade_deadline=None)
factories.SeatFactory(course_run=unpublished_course_run,
type=Seat.VERIFIED,
upgrade_deadline=None)
program = factories.ProgramFactory(
courses=[published_course_run.course],
one_click_purchase_enabled=True,
type=program_type,
)
self.assertTrue(program.is_program_eligible_for_one_click_purchase)
def create_program_with_seats(self):
currency = Currency.objects.get(code='USD')
course_run = factories.CourseRunFactory()
course_run.course.canonical_course_run = course_run
course_run.course.save()
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 create_program_with_multiple_course_runs(self, set_all_dates=True):
currency = Currency.objects.get(code='USD')
single_course_course_runs = factories.CourseRunFactory.create_batch(3)
course = factories.CourseFactory()
course_runs_same_course = factories.CourseRunFactory.create_batch(
3, course=course)
for course_run in single_course_course_runs:
factories.SeatFactory(type='audit',
currency=currency,
course_run=course_run,
price=0)
factories.SeatFactory(type='verified',
currency=currency,
course_run=course_run,
price=10)
course_run.course.canonical_course_run = course_run
course_run.course.save()
day_separation = 1
now = datetime.datetime.utcnow()
for course_run in course_runs_same_course:
if set_all_dates or day_separation < 2:
date_delta = datetime.timedelta(days=day_separation)
course_run.enrollment_start = now - date_delta
course_run.end = now + datetime.timedelta(weeks=day_separation)
else:
course_run.enrollment_start = None
course_run.end = None
course_run.save()
factories.SeatFactory(type='audit',
currency=currency,
course_run=course_run,
price=0)
factories.SeatFactory(type='verified',
currency=currency,
course_run=course_run,
price=(day_separation * 100))
day_separation += 1
course.canonical_course_run = course_runs_same_course[2]
course.save()
applicable_seat_types = SeatType.objects.filter(slug__in=['verified'])
program_type = factories.ProgramTypeFactory(
applicable_seat_types=applicable_seat_types)
program_courses = [
course_run.course for course_run in single_course_course_runs
]
program_courses.append(course)
return factories.ProgramFactory(type=program_type,
courses=program_courses)
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):
assert list(program_filter.queryset({}, Program.objects.all())) == \
[one_click_purchase_eligible_program, one_click_purchase_ineligible_program]
def test_one_click_purchase_eligible(self):
""" Verify that program is one click purchase eligible. """
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 True,
# all courses have one course run, all course runs have
# verified seat types
courses = []
for __ in range(3):
course_run = factories.CourseRunFactory(end=None,
enrollment_end=None)
factories.SeatFactory(course_run=course_run,
type=Seat.VERIFIED,
upgrade_deadline=None)
courses.append(course_run.course)
program = factories.ProgramFactory(
courses=courses,
one_click_purchase_enabled=True,
type=program_type,
)
self.assertTrue(program.is_program_eligible_for_one_click_purchase)
# Program has one_click_purchase_enabled set to True,
# course has all course runs excluded except one which
# has verified seat type
course_run = factories.CourseRunFactory(end=None, enrollment_end=None)
factories.SeatFactory(course_run=course_run,
type=Seat.VERIFIED,
upgrade_deadline=None)
course = course_run.course
excluded_course_runs = [
factories.CourseRunFactory(course=course),
factories.CourseRunFactory(course=course)
]
program = factories.ProgramFactory(
courses=[course],
excluded_course_runs=excluded_course_runs,
one_click_purchase_enabled=True,
type=program_type,
)
self.assertTrue(program.is_program_eligible_for_one_click_purchase)
def test_canonical_course_seats(self):
""" Test canonical course seats returns only canonical course run's applicable seats """
currency = Currency.objects.get(code='USD')
course = factories.CourseFactory()
course_runs_same_course = factories.CourseRunFactory.create_batch(
3, course=course)
for course_run in course_runs_same_course:
factories.SeatFactory(type='verified',
currency=currency,
course_run=course_run,
price=100)
course.canonical_course_run = course_runs_same_course[0]
course.save()
applicable_seat_types = SeatType.objects.filter(slug__in=['verified'])
program_type = factories.ProgramTypeFactory(
applicable_seat_types=applicable_seat_types)
program = factories.ProgramFactory(type=program_type, courses=[course])
self.assertEqual(set(course.canonical_course_run.seats.all()),
set(program.canonical_seats))
def test_str(self):
program_type = factories.ProgramTypeFactory()
self.assertEqual(str(program_type), program_type.name)
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,
)
