def test_contains_catalog_list_parent_key(self):
"""
Verify the contains_content_items endpoint returns a list of catalogs the course is in
"""
content_metadata = ContentMetadataFactory()
self.add_metadata_to_catalog(self.enterprise_catalog,
[content_metadata])
# Create a two catalogs that have the content we're looking for
parent_content_key = 'fake-parent-key+105x'
content_key = 'fake-key+101x'
second_catalog = EnterpriseCatalogFactory(
enterprise_uuid=self.enterprise_uuid)
relevant_content = ContentMetadataFactory(
content_key=content_key, parent_content_key=parent_content_key)
self.add_metadata_to_catalog(second_catalog, [relevant_content])
content_key_2 = 'fake-key+102x'
third_catalog = EnterpriseCatalogFactory(
enterprise_uuid=self.enterprise_uuid)
relevant_content = ContentMetadataFactory(
content_key=content_key_2, parent_content_key=parent_content_key)
self.add_metadata_to_catalog(third_catalog, [relevant_content])
url = self._get_contains_content_base_url(
) + '?course_run_ids=' + parent_content_key + '&get_catalog_list=True'
response = self.client.get(url).json()
assert response['contains_content_items'] is True
catalog_list = response['catalog_list']
assert set(catalog_list) == {
str(second_catalog.uuid),
str(third_catalog.uuid)
}
def setUpTestData(cls):
super().setUpTestData()
cls.catalog_query_a = CatalogQueryFactory()
cls.catalog_query_b = CatalogQueryFactory()
cls.enterprise_catalog_a = EnterpriseCatalogFactory(
catalog_query=cls.catalog_query_a)
cls.enterprise_catalog_b = EnterpriseCatalogFactory(
catalog_query=cls.catalog_query_b)
ContentMetadataFactory.create_batch(3)
def test_multiple_catalogs_for_catalog_admins(self,
is_role_assigned_via_jwt):
"""
Verify the viewset returns multiple catalogs for catalog admins of two different enterprises.
"""
second_enterprise_catalog = EnterpriseCatalogFactory(
enterprise_uuid=uuid.uuid4())
if is_role_assigned_via_jwt:
self.assign_catalog_admin_jwt_role(
self.enterprise_uuid,
second_enterprise_catalog.enterprise_uuid,
)
else:
self.assign_catalog_admin_feature_role(enterprise_uuids=[
self.enterprise_uuid,
second_enterprise_catalog.enterprise_uuid,
])
url = reverse('api:v1:enterprise-catalog-list')
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 2)
results = response.data['results']
self.assertEqual(uuid.UUID(results[0]['uuid']),
self.enterprise_catalog.uuid)
self.assertEqual(uuid.UUID(results[1]['uuid']),
second_enterprise_catalog.uuid)
def setUp(self):
super().setUp()
# Set up catalog.has_learner_access permissions
self.set_up_catalog_learner()
self.enterprise_catalog = EnterpriseCatalogFactory(
enterprise_uuid=self.enterprise_uuid)
# Delete any existing ContentMetadata records.
ContentMetadata.objects.all().delete()
def setUp(self):
super().setUp()
self.set_up_staff()
self.catalog_query = CatalogQueryFactory()
self.enterprise_catalog = EnterpriseCatalogFactory(
enterprise_uuid=self.enterprise_uuid,
catalog_query=self.catalog_query,
)
def test_get_content_metadata_unauthorized_incorrect_jwt_context(self):
"""
Verify the get_content_metadata endpoint rejects catalog learners
with an incorrect JWT context (i.e., enterprise uuid)
"""
enterprise_catalog = EnterpriseCatalogFactory()
self.remove_role_assignments()
url = self._get_content_metadata_url(enterprise_catalog)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_contains_content_items_unauthorized_incorrect_jwt_context(self):
"""
Verify the contains_content_items endpoint rejects users with an invalid JWT context (i.e., enterprise uuid)
"""
enterprise_catalog = EnterpriseCatalogFactory()
self.remove_role_assignments()
url = self._get_contains_content_base_url(
enterprise_catalog) + '?course_run_ids=fakeX'
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_put_unauthorized_incorrect_jwt_context(self):
"""
Verify the viewset rejects put for users that are catalog admins with an invalid
context (i.e., enterprise uuid)
"""
enterprise_catalog = EnterpriseCatalogFactory()
self.remove_role_assignments()
url = reverse('api:v1:enterprise-catalog-detail',
kwargs={'uuid': enterprise_catalog.uuid})
response = self.client.put(url, self.new_catalog_data)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_contains_content_items_no_catalog_query(self):
"""
Verify the contains_content_items endpoint returns False if there is no associated catalog query
"""
no_catalog_query_catalog = EnterpriseCatalogFactory(
catalog_query=None,
enterprise_uuid=self.enterprise_uuid,
)
url = self._get_contains_content_base_url(
no_catalog_query_catalog) + '?program_uuids=test-uuid'
self.assert_correct_contains_response(url, False)
def setUpTestData(cls):
super().setUpTestData()
cls.ALGOLIA_FIELDS = [
'key', 'objectID', 'enterprise_customer_uuids',
'enterprise_catalog_uuids'
]
# Set up a catalog, query, and metadata for a course
cls.enterprise_catalog_courses = EnterpriseCatalogFactory()
courses_catalog_query = cls.enterprise_catalog_courses.catalog_query
cls.course_metadata = ContentMetadataFactory(content_type=COURSE,
content_key='fakeX')
cls.course_metadata.catalog_queries.set([courses_catalog_query])
# Set up new catalog, query, and metadata for a course run
cls.enterprise_catalog_course_runs = EnterpriseCatalogFactory()
course_runs_catalog_query = cls.enterprise_catalog_course_runs.catalog_query
course_run_metadata = ContentMetadataFactory(
content_type=COURSE_RUN, parent_content_key='fakeX')
course_run_metadata.catalog_queries.set([course_runs_catalog_query])
def setUp(self):
super().setUp()
# clean up any stale test objects
CatalogQuery.objects.all().delete()
ContentMetadata.objects.all().delete()
EnterpriseCatalog.objects.all().delete()
self.enterprise_catalog = EnterpriseCatalogFactory(
enterprise_uuid=self.enterprise_uuid)
# Set up catalog.has_learner_access permissions
self.set_up_catalog_learner()
def test_get_content_metadata_no_catalog_query(self):
"""
Verify the get_content_metadata endpoint returns no results if the catalog has no catalog query
"""
no_catalog_query_catalog = EnterpriseCatalogFactory(
catalog_query=None,
enterprise_uuid=self.enterprise_uuid,
)
url = self._get_content_metadata_url(no_catalog_query_catalog)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json()['results'], [])
def setUpTestData(cls):
super().setUpTestData()
cls.ALGOLIA_FIELDS = [
'key', 'objectID', 'enterprise_customer_uuids',
'enterprise_catalog_uuids', 'enterprise_catalog_query_uuids'
]
# Set up a catalog, query, and metadata for a course
cls.enterprise_catalog_courses = EnterpriseCatalogFactory()
courses_catalog_query = cls.enterprise_catalog_courses.catalog_query
cls.course_metadata_published = ContentMetadataFactory(
content_type=COURSE, content_key='fakeX')
cls.course_metadata_published.catalog_queries.set(
[courses_catalog_query])
cls.course_metadata_unpublished = ContentMetadataFactory(
content_type=COURSE, content_key='testX')
cls.course_metadata_unpublished.json_metadata.get(
'course_runs')[0].update({
'status': 'unpublished',
})
cls.course_metadata_unpublished.catalog_queries.set(
[courses_catalog_query])
cls.course_metadata_unpublished.save()
# Set up new catalog, query, and metadata for a course run
cls.enterprise_catalog_course_runs = EnterpriseCatalogFactory()
course_runs_catalog_query = cls.enterprise_catalog_course_runs.catalog_query
course_run_metadata_published = ContentMetadataFactory(
content_type=COURSE_RUN, parent_content_key='fakeX')
course_run_metadata_published.catalog_queries.set(
[course_runs_catalog_query])
course_run_metadata_unpublished = ContentMetadataFactory(
content_type=COURSE_RUN, parent_content_key='testX')
course_run_metadata_unpublished.json_metadata.update({
'status':
'unpublished',
})
course_run_metadata_unpublished.catalog_queries.set(
[course_runs_catalog_query])
course_run_metadata_unpublished.save()
def test_every_catalog_for_catalog_admins(self, is_role_assigned_via_jwt):
"""
Verify the viewset returns catalogs of all enterprises for admins with wildcard permission.
"""
if is_role_assigned_via_jwt:
self.assign_catalog_admin_jwt_role('*')
else:
# This will cause a feature role assignment to be created with a null enterprise UUID,
# which is interpretted as having access to catalogs of ANY enterprise.
self.assign_catalog_admin_feature_role(enterprise_uuids=[None])
catalog_b = EnterpriseCatalogFactory(enterprise_uuid=uuid.uuid4())
catalog_c = EnterpriseCatalogFactory(enterprise_uuid=uuid.uuid4())
url = reverse('api:v1:enterprise-catalog-list')
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 3)
results = response.data['results']
self.assertEqual(uuid.UUID(results[0]['uuid']),
self.enterprise_catalog.uuid)
self.assertEqual(uuid.UUID(results[1]['uuid']), catalog_b.uuid)
self.assertEqual(uuid.UUID(results[2]['uuid']), catalog_c.uuid)
def test_list_for_superusers(self):
"""
Verify the viewset returns a list of all enterprise catalogs for superusers
"""
self.set_up_superuser()
url = reverse('api:v1:enterprise-catalog-list')
second_enterprise_catalog = EnterpriseCatalogFactory()
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 2)
results = response.data['results']
self.assertEqual(uuid.UUID(results[0]['uuid']),
self.enterprise_catalog.uuid)
self.assertEqual(uuid.UUID(results[1]['uuid']),
second_enterprise_catalog.uuid)
def setUp(self):
super().setUp()
self.set_up_staff()
self.enterprise_catalog = EnterpriseCatalogFactory(
enterprise_uuid=self.enterprise_uuid,
enterprise_name=self.enterprise_name,
)
self.new_catalog_uuid = uuid.uuid4()
self.new_catalog_data = {
'uuid': self.new_catalog_uuid,
'title': 'Test Title',
'enterprise_customer': self.enterprise_uuid,
'enterprise_customer_name': self.enterprise_name,
'enabled_course_modes': '["verified"]',
'publish_audit_enrollment_urls': True,
'content_filter': '{"content_type":"course"}',
}
def test_no_catalog_list_given_without_get_catalog_list_query(self):
"""
Verify that the contains_content_items endpoint does not return a list of catalogs without a querystring
"""
content_metadata = ContentMetadataFactory()
self.add_metadata_to_catalog(self.enterprise_catalog,
[content_metadata])
# Create a second catalog that has the content we're looking for
content_key = 'fake-key+101x'
second_catalog = EnterpriseCatalogFactory(
enterprise_uuid=self.enterprise_uuid)
relevant_content = ContentMetadataFactory(content_key=content_key)
self.add_metadata_to_catalog(second_catalog, [relevant_content])
url = self._get_contains_content_base_url(
) + '?course_run_ids=' + content_key
response = self.client.get(url)
assert 'catalog_list' not in response.json().keys()
def test_contains_content_items_in_catalogs(self):
"""
Verify the contains_content_items endpoint returns True if the content is in any associated catalog
"""
content_metadata = ContentMetadataFactory()
self.add_metadata_to_catalog(self.enterprise_catalog,
[content_metadata])
# Create a second catalog that has the content we're looking for
content_key = 'fake-key+101x'
second_catalog = EnterpriseCatalogFactory(
enterprise_uuid=self.enterprise_uuid)
relevant_content = ContentMetadataFactory(content_key=content_key)
self.add_metadata_to_catalog(second_catalog, [relevant_content])
url = self._get_contains_content_base_url(
) + '?course_run_ids=' + content_key
self.assert_correct_contains_response(url, True)
def test_one_catalog_for_catalog_admins(self, is_role_assigned_via_jwt):
"""
Verify the viewset returns a single catalog (when multiple exist) for catalog admins of a certain enterprise.
"""
if is_role_assigned_via_jwt:
self.assign_catalog_admin_jwt_role()
else:
self.assign_catalog_admin_feature_role()
# create an additional catalog from a different enterprise,
# and make sure we don't see it in the response results.
EnterpriseCatalogFactory(enterprise_uuid=uuid.uuid4())
url = reverse('api:v1:enterprise-catalog-list')
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
results = response.data['results']
self.assertEqual(uuid.UUID(results[0]['uuid']),
self.enterprise_catalog.uuid)
def test_contains_catalog_list(self):
"""
Verify the contains_content_items endpoint returns a list of catalogs the course is in if the correct
parameter is passed
"""
content_metadata = ContentMetadataFactory()
self.add_metadata_to_catalog(self.enterprise_catalog,
[content_metadata])
# Create a two catalogs that have the content we're looking for
content_key = 'fake-key+101x'
second_catalog = EnterpriseCatalogFactory(
enterprise_uuid=self.enterprise_uuid)
relevant_content = ContentMetadataFactory(content_key=content_key)
self.add_metadata_to_catalog(second_catalog, [relevant_content])
url = self._get_contains_content_base_url(
) + '?course_run_ids=' + content_key + '&get_catalog_list=True'
self.assert_correct_contains_response(url, True)
response = self.client.get(url)
catalog_list = response.json()['catalog_list']
assert set(catalog_list) == {str(second_catalog.uuid)}
def setUpTestData(cls):
super().setUpTestData()
cls.enterprise_catalog = EnterpriseCatalogFactory()
cls.catalog_query = cls.enterprise_catalog.catalog_query
def setUp(self):
super().setUp()
self.set_up_staff_user()
self.enterprise_catalog = EnterpriseCatalogFactory(
enterprise_uuid=self.enterprise_uuid)
def setUp(self):
super().setUp()
# Set up catalog.has_learner_access permissions
self.set_up_catalog_learner()
self.enterprise_catalog = EnterpriseCatalogFactory(
enterprise_uuid=self.enterprise_uuid)