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 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_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_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'])