def test_program_available_now_if_program_type_is_masters(self):
program_type = ProgramTypeFactory()
program_type.slug = 'masters'
program = AlgoliaProxyProgramFactory(partner=self.__class__.edxPartner,
type=program_type)
assert program.availability_level == 'Available now'
def setUp(self):
super().setUp()
self.pk_generator = itertools.count(1)
stored_site, created = Site.objects.get_or_create( # pylint: disable=unused-variable
domain='example.com')
self.default_partner = Partner.objects.create(site=stored_site,
name='edX',
short_code='edx')
SeatType.objects.all().delete()
ProgramType.objects.all().delete()
self.partner = PartnerFactory(name='Test')
self.organization = OrganizationFactory(partner=self.partner)
self.seat_type_verified = SeatTypeFactory(name='Verified',
slug='verified')
self.program_type_masters = ProgramTypeFactory(
name='Masters',
name_t='Masters',
slug='masters',
applicable_seat_types=[self.seat_type_verified])
self.program_type_masters_translation = self.program_type_masters.translations.all(
)[0]
self.program_type_mm = ProgramTypeFactory(
name='MicroMasters',
name_t='MicroMasters',
slug='micromasters',
applicable_seat_types=[self.seat_type_verified])
self.program_type_mm_translation = self.program_type_mm.translations.all(
)[0]
self.course = CourseFactory(
partner=self.partner, authoring_organizations=[self.organization])
self.course_run = CourseRunFactory(course=self.course)
self.program = ProgramFactory(
type=self.program_type_masters,
partner=self.partner,
authoring_organizations=[self.organization])
self.course_mm = CourseFactory(
partner=self.partner, authoring_organizations=[self.organization])
self.course_run_mm = CourseRunFactory(course=self.course)
self.program_mm = ProgramFactory(
type=self.program_type_mm,
partner=self.partner,
authoring_organizations=[self.organization],
courses=[self.course_mm])
self.curriculum = CurriculumFactory(program=self.program)
self.curriculum_course_membership = CurriculumCourseMembershipFactory(
course=self.course, curriculum=self.curriculum)
self.curriculum_program_membership = CurriculumProgramMembershipFactory(
program=self.program_mm, curriculum=self.curriculum)
self.program_2 = ProgramFactory(
type=self.program_type_masters,
partner=self.partner,
authoring_organizations=[self.organization])
self._mock_oauth_request()
def test_list(self):
""" Verify the endpoint returns a list of all program types. """
ProgramTypeFactory.create_batch(4)
expected = ProgramType.objects.all()
with self.assertNumQueries(6):
response = self.client.get(self.list_path)
assert response.status_code == 200
assert response.data['results'] == self.serialize_program_type(expected, many=True)
def test_update_existing_program_type(self):
fixture = json_serializer.Serializer().serialize([
self.organization,
self.seat_type_verified,
self.program_type_masters,
self.program,
])
self._mock_fixture_response(fixture)
self.reset_db_state()
# set DB to have a conflicting program type on load
seat_type = SeatTypeFactory(
name='Something',
slug='something',
)
existing_program_type = ProgramTypeFactory(
name='Masters', slug='masters', applicable_seat_types=[seat_type])
self._call_load_program_fixture([str(self.program.uuid)])
stored_program = Program.objects.get(uuid=self.program.uuid)
# assert existing DB value is used
stored_program_type = stored_program.type
self.assertEqual(stored_program_type, existing_program_type)
# assert existing DB value is updated to match fixture
stored_seat_types = list(
stored_program_type.applicable_seat_types.all())
self.assertEqual(len(stored_seat_types), 1)
self.assertEqual(stored_seat_types[0].name,
self.seat_type_verified.name)
def setUp(self):
super().setUp()
self.user = UserFactory()
self.staff = UserFactory(username='******', is_staff=True)
seat_type = SeatTypeFactory(name="TestSeatType")
self.program_type = ProgramTypeFactory(
name="TestProgramType",
slug="test-program-type",
applicable_seat_types=[seat_type],
)
def test_retrieve(self):
""" The request should return details for a single program type. """
program_type = ProgramTypeFactory()
url = reverse('api:v1:program_type-detail', kwargs={'slug': program_type.slug})
with self.assertNumQueries(5):
response = self.client.get(url)
assert response.status_code == 200
assert response.data == self.serialize_program_type(program_type)
def _set_up_masters_program_type(self):
"""
Set DB to have a conflicting program type on load.
"""
seat_type = SeatTypeFactory(
name='Something',
slug='something',
)
existing_program_type = ProgramTypeFactory(
name='Masters',
name_t='Masters',
slug='masters',
applicable_seat_types=[seat_type])
return existing_program_type
def test_list(self):
""" Verify the endpoint returns a list of all program_types. """
ProgramTypeFactory.create_batch(3)
expected = ProgramType.objects.all()
self.assert_list_results(self.list_path, expected, 4)
def test_list(self):
""" Verify the endpoint returns a list of all program_types. """
ProgramTypeFactory.create_batch(3)
expected = ProgramType.objects.all()
self.assert_list_results(self.list_path, expected, 4)
