def test_import_toy(self):
"""
Simplest possible test.
"""
resource_count = get_resources(self.repo.id).count()
course_count = Course.objects.count()
import_course_from_file(self.course_zip, self.repo.id, self.user.id)
self.assertEqual(
get_resources(self.repo.id).count(),
resource_count + self.toy_resource_count)
self.assertEqual(
Course.objects.count(),
course_count + 1,
)
def test_import_toy(self):
"""
Simplest possible test.
"""
resource_count = get_resources(self.repo.id).count()
course_count = Course.objects.count()
import_course_from_file(self.course_zip, self.repo.id, self.user.id)
self.assertEqual(
get_resources(self.repo.id).count(),
resource_count + self.toy_resource_count)
self.assertEqual(
Course.objects.count(),
course_count + 1,
)
def import_course(bundle, repo_id, user_id, static_dir):
"""
Import a course from an XBundle object.
Args:
bundle (xbundle.XBundle): Course as xbundle XML
repo_id (int): Primary key of repository course belongs to
user_id (int): Primary key of Django user doing the import
static_dir (unicode): location of static files
Returns:
learningresources.models.Course
"""
src = bundle.course
course = create_course(
org=src.attrib["org"],
repo_id=repo_id,
course_number=src.attrib["course"],
run=src.attrib["semester"],
user_id=user_id,
)
import_static_assets(course, static_dir)
import_children(course, src, None, '')
populate_xanalytics_fields.delay(course.id)
# This triggers a bulk indexing of all LearningResource instances
# for the course at once.
index_resources(
get_resources(repo_id).filter(course__id=course.id))
return course
def import_course(bundle, repo_id, user_id, static_dir):
"""
Import a course from an XBundle object.
Args:
bundle (xbundle.XBundle): Course as xbundle XML
repo_id (int): Primary key of repository course belongs to
user_id (int): Primary key of Django user doing the import
static_dir (unicode): location of static files
Returns:
learningresources.models.Course
"""
src = bundle.course
course = create_course(
org=src.attrib["org"],
repo_id=repo_id,
course_number=src.attrib["course"],
run=src.attrib["semester"],
user_id=user_id,
)
import_static_assets(course, static_dir)
import_children(course, src, None, '')
populate_xanalytics_fields.delay(course.id)
# This triggers a bulk indexing of all LearningResource instances
# for the course at once.
index_resources(
get_resources(repo_id).filter(course__id=course.id).values_list(
"id", flat=True))
return course
def test_learning_resource_filter(self):
"""Test for filtering LearningResources by ids."""
def get_filtered(ids, expected_status=HTTP_200_OK):
"""Return list of LearningResources in shopping cart."""
url_base = "{repo_base}{repo_slug}/learning_resources/".format(
repo_base=REPO_BASE,
repo_slug=self.repo.slug,
)
resp = self.client.get("{url_base}?id={ids}".format(
url_base=url_base,
ids=",".join([str(s) for s in ids])
))
self.assertEqual(expected_status, resp.status_code)
if expected_status == HTTP_200_OK:
return sorted([x['id'] for x in as_json(resp)['results']])
self.import_course_tarball(self.repo)
self.assertEqual([], get_filtered([]))
get_filtered(["not-a-number"],
expected_status=HTTP_400_BAD_REQUEST)
self.assertEqual([], get_filtered([-1]))
all_ids = list(get_resources(
self.repo.id).values_list('id', flat=True))
self.assertEqual(sorted(all_ids), get_filtered(all_ids))
self.assertEqual(
sorted(all_ids[:5]), get_filtered(all_ids[:5]))
def get_resource_with_asset(type_name):
"""
Get a LearningResource with a StaticAsset.
"""
for resource in get_resources(self.repo.id):
if (resource.learning_resource_type.name != type_name or
resource.static_assets.count() == 0):
continue
return resource
def get_resource_with_asset(type_name):
"""
Get a LearningResource with a StaticAsset.
"""
for resource in get_resources(self.repo.id):
if (resource.learning_resource_type.name != type_name or
resource.static_assets.count() == 0):
continue
return resource
def import_course_tarball(self, repo):
"""
Import course.xml into repo and return first LearningResource
which has any StaticAssets.
"""
tarball_file = self.get_course_single_tarball()
import_file(tarball_file, repo.id, self.user.id)
return get_resources(
repo.id).annotate(count_assets=Count('static_assets')).filter(
count_assets__gt=0).first()
def import_course_tarball(self, repo):
"""
Import course.xml into repo and return first LearningResource
which has any StaticAssets.
"""
tarball_file = self.get_course_single_tarball()
import_file(
tarball_file, repo.id, self.user.id)
return get_resources(repo.id).annotate(
count_assets=Count('static_assets')
).filter(count_assets__gt=0).first()
def test_static_assets_create(self):
"""Test for creating StaticAsset from learning_resources."""
lr_id = get_resources(self.repo.id).first().id
resp = self.client.post(
'{repo_base}{repo_slug}/learning_resources/'
'{lr_id}/static_assets/'.format(
repo_base=REPO_BASE,
repo_slug=self.repo.slug,
lr_id=lr_id,
),
self.DEFAULT_LR_DICT
)
self.assertEqual(resp.status_code, HTTP_405_METHOD_NOT_ALLOWED)
def test_static_assets_create(self):
"""Test for creating StaticAsset from learning_resources."""
lr_id = get_resources(self.repo.id).first().id
resp = self.client.post(
'{repo_base}{repo_slug}/learning_resources/'
'{lr_id}/static_assets/'.format(
repo_base=REPO_BASE,
repo_slug=self.repo.slug,
lr_id=lr_id,
),
self.DEFAULT_LR_DICT
)
self.assertEqual(resp.status_code, HTTP_405_METHOD_NOT_ALLOWED)
def test_learning_resource_exports_anonymous(self):
"""Make sure anonymous users are forbidden."""
lr_id = get_resources(self.repo.id).first().id
self.logout()
self.get_learning_resource_export(
self.repo.slug, lr_id, username="******",
expected_status=HTTP_403_FORBIDDEN)
self.get_learning_resource_exports(
self.repo.slug, username="******",
expected_status=HTTP_403_FORBIDDEN)
self.create_learning_resource_export(
self.repo.slug, {"id": lr_id}, username="******",
expected_status=HTTP_403_FORBIDDEN)
self.delete_learning_resource_export(
self.repo.slug, lr_id,
username="******",
expected_status=HTTP_403_FORBIDDEN)
self.delete_learning_resource_exports(
self.repo.slug, username="******",
expected_status=HTTP_403_FORBIDDEN)
def test_learning_resource_exports_anonymous(self):
"""Make sure anonymous users are forbidden."""
lr_id = get_resources(self.repo.id).first().id
self.logout()
self.get_learning_resource_export(
self.repo.slug, lr_id, username="******",
expected_status=HTTP_403_FORBIDDEN)
self.get_learning_resource_exports(
self.repo.slug, username="******",
expected_status=HTTP_403_FORBIDDEN)
self.create_learning_resource_export(
self.repo.slug, {"id": lr_id}, username="******",
expected_status=HTTP_403_FORBIDDEN)
self.delete_learning_resource_export(
self.repo.slug, lr_id,
username="******",
expected_status=HTTP_403_FORBIDDEN)
self.delete_learning_resource_exports(
self.repo.slug, username="******",
expected_status=HTTP_403_FORBIDDEN)
def test_missing_learning_resource(self):
"""Test for an invalid LearningResource id."""
repo_slug1 = self.repo.slug
resource1 = self.import_course_tarball(self.repo)
lr1_id = resource1.id
# import from a different course so it's not a duplicate course
zip_file = self.get_course_zip()
new_repo_dict = self.create_repository()
repo_slug2 = new_repo_dict['slug']
repo_id2 = new_repo_dict['id']
import_file(
zip_file, repo_id2, self.user.id)
resource2 = get_resources(repo_id2).first()
lr2_id = resource2.id
# repo_slug1 should own lr1_id and repo_slug2 should own lr2_id
self.get_learning_resource(repo_slug1, lr1_id)
self.get_learning_resource(repo_slug2, lr1_id,
expected_status=HTTP_404_NOT_FOUND)
self.get_learning_resource(repo_slug1, lr2_id,
expected_status=HTTP_404_NOT_FOUND)
self.get_learning_resource(repo_slug2, lr2_id)
def test_missing_learning_resource(self):
"""Test for an invalid LearningResource id."""
repo_slug1 = self.repo.slug
resource1 = self.import_course_tarball(self.repo)
lr1_id = resource1.id
# import from a different course so it's not a duplicate course
zip_file = self.get_course_zip()
new_repo_dict = self.create_repository()
repo_slug2 = new_repo_dict['slug']
repo_id2 = new_repo_dict['id']
import_file(
zip_file, repo_id2, self.user.id)
resource2 = get_resources(repo_id2).first()
lr2_id = resource2.id
# repo_slug1 should own lr1_id and repo_slug2 should own lr2_id
self.get_learning_resource(repo_slug1, lr1_id)
self.get_learning_resource(repo_slug2, lr1_id,
expected_status=HTTP_404_NOT_FOUND)
self.get_learning_resource(repo_slug1, lr2_id,
expected_status=HTTP_404_NOT_FOUND)
self.get_learning_resource(repo_slug2, lr2_id)
def test_learning_resource_filter(self):
"""Test for filtering LearningResources by ids."""
def get_filtered(ids=None, vocab_slug=None, types=None,
expected_status=HTTP_200_OK):
"""Return list of LearningResources in shopping cart."""
url_base = "{repo_base}{repo_slug}/learning_resources/".format(
repo_base=REPO_BASE,
repo_slug=self.repo.slug,
)
params = []
if ids is not None:
params.append("id={ids}".format(
ids=",".join([str(s) for s in ids])
))
if vocab_slug is not None:
params.append("vocab_slug={slug}".format(
slug=vocab_slug
))
if types is not None:
for type_name in types:
params.append("type_name={name}".format(name=type_name))
params_line = ""
if params:
params_line = "?" + "&".join(params)
resp = self.client.get("{url_base}{params_line}".format(
url_base=url_base,
params_line=params_line
))
self.assertEqual(expected_status, resp.status_code)
if expected_status == HTTP_200_OK:
return sorted([x['id'] for x in as_json(resp)['results']])
# Filter by id
self.import_course_tarball(self.repo)
self.assertEqual([], get_filtered(ids=[]))
get_filtered(ids=["not-a-number"],
expected_status=HTTP_400_BAD_REQUEST)
self.assertEqual([], get_filtered(ids=[-1]))
all_ids = list(get_resources(
self.repo.id).values_list('id', flat=True))
self.assertEqual(sorted(all_ids), get_filtered(ids=all_ids))
self.assertEqual(
sorted(all_ids[:5]), get_filtered(ids=all_ids[:5]))
# Assign term to resource
vocab1_slug = self.create_vocabulary(self.repo.slug)['slug']
term1_slug = self.create_term(self.repo.slug, vocab1_slug)['slug']
vocab2_dict = dict(self.DEFAULT_VOCAB_DICT)
vocab2_dict['name'] = 'two'
vocab2_slug = self.create_vocabulary(
self.repo.slug, vocab2_dict)['slug']
term2_slug = self.create_term(
self.repo.slug, vocab2_slug)['slug']
resource1 = get_resource(all_ids[0], self.user.id)
resource2 = get_resource(all_ids[1], self.user.id)
# Verify no vocabularies come up in filter
self.assertEqual([], get_filtered(vocab_slug=vocab1_slug))
self.assertEqual([], get_filtered(vocab_slug=vocab2_slug))
# Assign terms
resource1.terms.add(Term.objects.get(slug=term1_slug))
resource2.terms.add(Term.objects.get(slug=term2_slug))
# Filter by vocabulary
self.assertEqual(
[resource1.id], get_filtered(vocab_slug=vocab1_slug)
)
self.assertEqual(
[resource1.id], get_filtered(
ids=[resource1.id], vocab_slug=vocab1_slug
)
)
self.assertEqual(
[], get_filtered(
ids=[resource2.id], vocab_slug=vocab1_slug
)
)
self.assertEqual(
[], get_filtered(
ids=[resource1.id], vocab_slug=vocab2_slug
)
)
# Filter by type
self.assertNotEqual(
resource1.learning_resource_type.name,
resource2.learning_resource_type.name
)
self.assertEqual(
sorted([lr.id for lr in LearningResource.objects.filter(
learning_resource_type=resource1.learning_resource_type
)]), get_filtered(
types=[resource1.learning_resource_type.name]
)
)
self.assertEqual(
sorted([lr.id for lr in LearningResource.objects.filter(
learning_resource_type=resource2.learning_resource_type
)]), get_filtered(
types=[resource2.learning_resource_type.name]
)
)
self.assertEqual(
[], get_filtered(
types=["missing"]
)
)
def test_learning_resource_exports(self):
"""Test for creating LearningResource ids in session shopping cart."""
# set up our data
self.logout()
self.login(self.add_repo_user)
repo_slug1 = self.repo.slug
repo_slug2 = self.create_repository()['slug']
repo2 = Repository.objects.get(slug=repo_slug2)
# 'add_repo_user' will be able to see both repos
assign_user_to_repo_group(
self.add_repo_user, self.repo, GroupTypes.REPO_ADMINISTRATOR)
self.import_course_tarball(repo2)
repo1_lrid1 = get_resources(self.repo.id).all()[0].id
repo2_lrid1 = get_resources(repo2.id).all()[0].id
repo2_lrid2 = get_resources(repo2.id).all()[1].id
self.logout()
self.login(self.user)
# make sure we start with an empty shopping cart
self.assertEqual([],
self.get_learning_resource_exports(
repo_slug1)['results'])
self.create_learning_resource_export(self.repo.slug, {
'id': repo1_lrid1
})
self.assertEqual([{'id': repo1_lrid1}],
self.get_learning_resource_exports(
repo_slug1)['results'])
# user doesn't have access to repo2
self.get_learning_resource_exports(
repo_slug2, expected_status=HTTP_403_FORBIDDEN)
self.logout()
self.login(self.add_repo_user)
# make sure that session is not shared between users
# user has an id in repo1 but add_repo_user does not
self.assertEqual([], self.get_learning_resource_exports(
repo_slug1
)['results'])
# don't store duplicates
self.create_learning_resource_export(repo_slug1, {"id": repo1_lrid1})
self.create_learning_resource_export(repo_slug1, {"id": repo1_lrid1})
self.assertEqual(
[{"id": repo1_lrid1}],
self.get_learning_resource_exports(
repo_slug1
)['results'])
# make sure export ids are confined to their own repos
self.create_learning_resource_export(repo_slug2, {
'id': repo2_lrid1
})
# not affected by POST in previous line
self.assertEqual([{'id': repo1_lrid1}],
self.get_learning_resource_exports(
repo_slug1)['results'])
# contains the new item
self.assertEqual([{'id': repo2_lrid1}],
self.get_learning_resource_exports(
repo_slug2)['results'])
# make sure we can't add export ids that don't belong to the repo
self.create_learning_resource_export(repo_slug1, {
'id': repo2_lrid1
}, expected_status=HTTP_403_FORBIDDEN)
# make sure detail view will 404 if out of bounds
self.assertEqual(repo1_lrid1, self.get_learning_resource_export(
repo_slug1, repo1_lrid1)['id'])
self.get_learning_resource_export(
repo_slug1, repo2_lrid1,
expected_status=HTTP_404_NOT_FOUND)
self.get_learning_resource_export(
repo_slug2, repo1_lrid1,
expected_status=HTTP_404_NOT_FOUND)
self.assertEqual(repo2_lrid1, self.get_learning_resource_export(
repo_slug2, repo2_lrid1)['id'])
self.create_learning_resource_export(repo_slug2, {"id": repo2_lrid1})
self.create_learning_resource_export(repo_slug2, {"id": repo2_lrid2})
# finally, delete all of the things
self.assertEqual(
2, self.get_learning_resource_exports(repo_slug2)['count'])
self.delete_learning_resource_exports(repo_slug2)
self.assertEqual(
0, self.get_learning_resource_exports(repo_slug2)['count'])
# make sure deleting an empty list doesn't cause problems
self.delete_learning_resource_exports(repo_slug2)
self.assertEqual(
0, self.get_learning_resource_exports(repo_slug2)['count'])
# repo1 is unaffected
self.assertEqual(
1, self.get_learning_resource_exports(repo_slug1)['count'])
self.delete_learning_resource_export(repo_slug1, repo1_lrid1)
self.get_learning_resource_export(
repo_slug1, repo1_lrid1, expected_status=HTTP_404_NOT_FOUND)
self.logout()
self.login(self.user)
# Populate shopping cart one more time.
self.create_learning_resource_export(repo_slug1, {"id": repo1_lrid1})
self.logout()
self.login(self.user)
# After logout and login session was cleared
self.assertEqual(
0, self.get_learning_resource_exports(repo_slug1)['count'])
def test_learning_resource_filter(self):
"""Test for filtering LearningResources by ids."""
def get_filtered(ids=None, vocab_slug=None, types=None,
expected_status=HTTP_200_OK):
"""Return list of LearningResources in shopping cart."""
url_base = "{repo_base}{repo_slug}/learning_resources/".format(
repo_base=REPO_BASE,
repo_slug=self.repo.slug,
)
params = []
if ids is not None:
params.append("id={ids}".format(
ids=",".join([str(s) for s in ids])
))
if vocab_slug is not None:
params.append("vocab_slug={slug}".format(
slug=vocab_slug
))
if types is not None:
for type_name in types:
params.append("type_name={name}".format(name=type_name))
params_line = ""
if params:
params_line = "?" + "&".join(params)
resp = self.client.get("{url_base}{params_line}".format(
url_base=url_base,
params_line=params_line
))
self.assertEqual(expected_status, resp.status_code)
if expected_status == HTTP_200_OK:
return sorted([x['id'] for x in as_json(resp)['results']])
# Filter by id
self.import_course_tarball(self.repo)
self.assertEqual([], get_filtered(ids=[]))
get_filtered(ids=["not-a-number"],
expected_status=HTTP_400_BAD_REQUEST)
self.assertEqual([], get_filtered(ids=[-1]))
all_ids = list(get_resources(
self.repo.id).values_list('id', flat=True))
self.assertEqual(sorted(all_ids), get_filtered(ids=all_ids))
self.assertEqual(
sorted(all_ids[:5]), get_filtered(ids=all_ids[:5]))
# Assign term to resource
vocab1_slug = self.create_vocabulary(self.repo.slug)['slug']
term1_slug = self.create_term(self.repo.slug, vocab1_slug)['slug']
vocab2_dict = dict(self.DEFAULT_VOCAB_DICT)
vocab2_dict['name'] = 'two'
vocab2_slug = self.create_vocabulary(
self.repo.slug, vocab2_dict)['slug']
term2_slug = self.create_term(
self.repo.slug, vocab2_slug)['slug']
resource1 = get_resource(all_ids[0], self.user.id)
resource2 = get_resource(all_ids[1], self.user.id)
# Verify no vocabularies come up in filter
self.assertEqual([], get_filtered(vocab_slug=vocab1_slug))
self.assertEqual([], get_filtered(vocab_slug=vocab2_slug))
# Assign terms
resource1.terms.add(Term.objects.get(slug=term1_slug))
resource2.terms.add(Term.objects.get(slug=term2_slug))
# Filter by vocabulary
self.assertEqual(
[resource1.id], get_filtered(vocab_slug=vocab1_slug)
)
self.assertEqual(
[resource1.id], get_filtered(
ids=[resource1.id], vocab_slug=vocab1_slug
)
)
self.assertEqual(
[], get_filtered(
ids=[resource2.id], vocab_slug=vocab1_slug
)
)
self.assertEqual(
[], get_filtered(
ids=[resource1.id], vocab_slug=vocab2_slug
)
)
# Filter by type
self.assertNotEqual(
resource1.learning_resource_type.name,
resource2.learning_resource_type.name
)
self.assertEqual(
sorted([lr.id for lr in LearningResource.objects.filter(
learning_resource_type=resource1.learning_resource_type
)]), get_filtered(
types=[resource1.learning_resource_type.name]
)
)
self.assertEqual(
sorted([lr.id for lr in LearningResource.objects.filter(
learning_resource_type=resource2.learning_resource_type
)]), get_filtered(
types=[resource2.learning_resource_type.name]
)
)
self.assertEqual(
[], get_filtered(
types=["missing"]
)
)
def test_learning_resource_exports(self):
"""Test for creating LearningResource ids in session shopping cart."""
# set up our data
self.logout()
self.login(self.add_repo_user)
repo_slug1 = self.repo.slug
repo_slug2 = self.create_repository()['slug']
repo2 = Repository.objects.get(slug=repo_slug2)
# 'add_repo_user' will be able to see both repos
assign_user_to_repo_group(
self.add_repo_user, self.repo, GroupTypes.REPO_ADMINISTRATOR)
self.import_course_tarball(repo2)
repo1_lrid1 = get_resources(self.repo.id).all()[0].id
repo2_lrid1 = get_resources(repo2.id).all()[0].id
repo2_lrid2 = get_resources(repo2.id).all()[1].id
self.logout()
self.login(self.user)
# make sure we start with an empty shopping cart
self.assertEqual([],
self.get_learning_resource_exports(
repo_slug1)['results'])
self.create_learning_resource_export(self.repo.slug, {
'id': repo1_lrid1
})
self.assertEqual([{'id': repo1_lrid1}],
self.get_learning_resource_exports(
repo_slug1)['results'])
# user doesn't have access to repo2
self.get_learning_resource_exports(
repo_slug2, expected_status=HTTP_403_FORBIDDEN)
self.logout()
self.login(self.add_repo_user)
# make sure that session is not shared between users
# user has an id in repo1 but add_repo_user does not
self.assertEqual([], self.get_learning_resource_exports(
repo_slug1
)['results'])
# don't store duplicates
self.create_learning_resource_export(repo_slug1, {"id": repo1_lrid1})
self.create_learning_resource_export(repo_slug1, {"id": repo1_lrid1})
self.assertEqual(
[{"id": repo1_lrid1}],
self.get_learning_resource_exports(
repo_slug1
)['results'])
# make sure export ids are confined to their own repos
self.create_learning_resource_export(repo_slug2, {
'id': repo2_lrid1
})
# not affected by POST in previous line
self.assertEqual([{'id': repo1_lrid1}],
self.get_learning_resource_exports(
repo_slug1)['results'])
# contains the new item
self.assertEqual([{'id': repo2_lrid1}],
self.get_learning_resource_exports(
repo_slug2)['results'])
# make sure we can't add export ids that don't belong to the repo
self.create_learning_resource_export(repo_slug1, {
'id': repo2_lrid1
}, expected_status=HTTP_403_FORBIDDEN)
# make sure detail view will 404 if out of bounds
self.assertEqual(repo1_lrid1, self.get_learning_resource_export(
repo_slug1, repo1_lrid1)['id'])
self.get_learning_resource_export(
repo_slug1, repo2_lrid1,
expected_status=HTTP_404_NOT_FOUND)
self.get_learning_resource_export(
repo_slug2, repo1_lrid1,
expected_status=HTTP_404_NOT_FOUND)
self.assertEqual(repo2_lrid1, self.get_learning_resource_export(
repo_slug2, repo2_lrid1)['id'])
self.create_learning_resource_export(repo_slug2, {"id": repo2_lrid1})
self.create_learning_resource_export(repo_slug2, {"id": repo2_lrid2})
# finally, delete all of the things
self.assertEqual(
2, self.get_learning_resource_exports(repo_slug2)['count'])
self.delete_learning_resource_exports(repo_slug2)
self.assertEqual(
0, self.get_learning_resource_exports(repo_slug2)['count'])
# make sure deleting an empty list doesn't cause problems
self.delete_learning_resource_exports(repo_slug2)
self.assertEqual(
0, self.get_learning_resource_exports(repo_slug2)['count'])
# repo1 is unaffected
self.assertEqual(
1, self.get_learning_resource_exports(repo_slug1)['count'])
self.delete_learning_resource_export(repo_slug1, repo1_lrid1)
self.get_learning_resource_export(
repo_slug1, repo1_lrid1, expected_status=HTTP_404_NOT_FOUND)
self.logout()
self.login(self.user)
# Populate shopping cart one more time.
self.create_learning_resource_export(repo_slug1, {"id": repo1_lrid1})
self.logout()
self.login(self.user)
# After logout and login session was cleared
self.assertEqual(
0, self.get_learning_resource_exports(repo_slug1)['count'])
