Andal.LND/edx-platform
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

BOM-2369 (C): pyupgrade on contentstore/tests (#26759)

Browse Source 
* pyupgrade on contentstore/tests
This commit is contained in:
M. Zulqarnain
2021-03-04 14:37:39 +05:00
committed by GitHub
parent da970bf215
commit fa271dafe9
25 changed files with 379 additions and 411 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
cms/djangoapps/contentstore/tests/test_clone_course.py
View File

@@ -4,10 +4,9 @@ Unit tests for cloning a course between the same and different module stores.
import json
from unittest.mock import Mock, patch
import six
from django.conf import settings
from mock import Mock, patch
from opaque_keys.edx.locator import CourseLocator
from cms.djangoapps.contentstore.tasks import rerun_course
@@ -58,7 +57,7 @@ class CloneCourseTest(CourseTestCase):
course_run = '2015_Q1'
display_name = 'rerun'
fields = {'display_name': display_name}
course_assets = set([u'subs_Introduction%20To%20New.srt.sjson'], )
course_assets = {'subs_Introduction%20To%20New.srt.sjson'}
# Create a course using split modulestore
course = CourseFactory.create(
@@ -79,14 +78,14 @@ class CloneCourseTest(CourseTestCase):
# Get & verify all assets of the course
assets, count = contentstore().get_all_content_for_course(course.id)
self.assertEqual(count, 1)
self.assertEqual(set([asset['asset_key'].block_id for asset in assets]), course_assets) # lint-amnesty, pylint: disable=consider-using-set-comprehension
self.assertEqual({asset['asset_key'].block_id for asset in assets}, course_assets) # lint-amnesty, pylint: disable=consider-using-set-comprehension
# rerun from split into split
split_rerun_id = CourseLocator(org=org, course=course_number, run="2012_Q2")
CourseRerunState.objects.initiated(course.id, split_rerun_id, self.user, fields['display_name'])
result = rerun_course.delay(
six.text_type(course.id),
six.text_type(split_rerun_id),
str(course.id),
str(split_rerun_id),
self.user.id,
json.dumps(fields, cls=EdxJSONEncoder)
)
@@ -109,7 +108,7 @@ class CloneCourseTest(CourseTestCase):
# Mark the action as initiated
fields = {'display_name': 'rerun'}
CourseRerunState.objects.initiated(mongo_course1_id, split_course3_id, self.user, fields['display_name'])
result = rerun_course.delay(six.text_type(mongo_course1_id), six.text_type(split_course3_id), self.user.id,
result = rerun_course.delay(str(mongo_course1_id), str(split_course3_id), self.user.id,
json.dumps(fields, cls=EdxJSONEncoder))
self.assertEqual(result.get(), "succeeded")
self.assertTrue(has_course_author_access(self.user, split_course3_id), "Didn't grant access")
@@ -117,7 +116,7 @@ class CloneCourseTest(CourseTestCase):
self.assertEqual(rerun_state.state, CourseRerunUIStateManager.State.SUCCEEDED)
# try creating rerunning again to same name and ensure it generates error
result = rerun_course.delay(six.text_type(mongo_course1_id), six.text_type(split_course3_id), self.user.id)
result = rerun_course.delay(str(mongo_course1_id), str(split_course3_id), self.user.id)
self.assertEqual(result.get(), "duplicate course")
# the below will raise an exception if the record doesn't exist
CourseRerunState.objects.find_first(
@@ -130,7 +129,7 @@ class CloneCourseTest(CourseTestCase):
split_course4_id = CourseLocator(org="edx3", course="split3", run="rerun_fail")
fields = {'display_name': 'total failure'}
CourseRerunState.objects.initiated(split_course3_id, split_course4_id, self.user, fields['display_name'])
result = rerun_course.delay(six.text_type(split_course3_id), six.text_type(split_course4_id), self.user.id,
result = rerun_course.delay(str(split_course3_id), str(split_course4_id), self.user.id,
json.dumps(fields, cls=EdxJSONEncoder))
self.assertIn("exception: ", result.get())
self.assertIsNone(self.store.get_course(split_course4_id), "Didn't delete course after error")

180
cms/djangoapps/contentstore/tests/test_contentstore.py
View File

@@ -7,13 +7,11 @@ from datetime import timedelta
from functools import wraps
from json import loads
from textwrap import dedent
from unittest import SkipTest
from unittest import SkipTest, mock
from uuid import uuid4
import ddt
import lxml.html
import mock
import six
from django.conf import settings
from django.contrib.auth.models import User # lint-amnesty, pylint: disable=imported-auth-user
from django.middleware.csrf import _compare_salted_tokens # lint-amnesty, pylint: disable=unused-import
@@ -26,8 +24,6 @@ from opaque_keys import InvalidKeyError
from opaque_keys.edx.keys import AssetKey, CourseKey, UsageKey
from opaque_keys.edx.locations import CourseLocator
from path import Path as path
from six import text_type
from six.moves import range
from waffle.testutils import override_switch
from cms.djangoapps.contentstore.config import waffle
@@ -36,11 +32,11 @@ from cms.djangoapps.contentstore.utils import delete_course, reverse_course_url,
from cms.djangoapps.contentstore.views.component import ADVANCED_COMPONENT_TYPES
from common.djangoapps.course_action_state.managers import CourseActionStateItemNotFoundError
from common.djangoapps.course_action_state.models import CourseRerunState, CourseRerunUIStateManager
from openedx.core.djangoapps.django_comment_common.utils import are_permissions_roles_seeded
from openedx.core.lib.tempdir import mkdtemp_clean
from common.djangoapps.student import auth
from common.djangoapps.student.models import CourseEnrollment
from common.djangoapps.student.roles import CourseCreatorRole, CourseInstructorRole
from openedx.core.djangoapps.django_comment_common.utils import are_permissions_roles_seeded
from openedx.core.lib.tempdir import mkdtemp_clean
from xmodule.capa_module import ProblemBlock
from xmodule.contentstore.content import StaticContent
from xmodule.contentstore.django import contentstore
@@ -124,7 +120,7 @@ class ImportRequiredTestCases(ContentStoreTestCase):
Asset name in XML: "/invalid\\displayname/subs-esLhHcdKGWvKs.srt"
"""
content_store = contentstore()
expected_displayname = u'_invalid_displayname_subs-esLhHcdKGWvKs.srt'
expected_displayname = '_invalid_displayname_subs-esLhHcdKGWvKs.srt'
import_course_from_xml(
self.store,
@@ -162,11 +158,11 @@ class ImportRequiredTestCases(ContentStoreTestCase):
# Test course export does not fail
root_dir = path(mkdtemp_clean())
print(u'Exporting to tempdir = {0}'.format(root_dir))
export_course_to_xml(self.store, content_store, course.id, root_dir, u'test_export')
print(f'Exporting to tempdir = {root_dir}')
export_course_to_xml(self.store, content_store, course.id, root_dir, 'test_export')
filesystem = OSFS(text_type(root_dir / 'test_export/static'))
exported_static_files = filesystem.listdir(u'/')
filesystem = OSFS(str(root_dir / 'test_export/static'))
exported_static_files = filesystem.listdir('/')
# Verify that asset have been overwritten during export.
self.assertEqual(len(exported_static_files), 1)
@@ -243,38 +239,38 @@ class ImportRequiredTestCases(ContentStoreTestCase):
self.assertIsNotNone(course_updates)
# check that course which is imported has files 'updates.html' and 'updates.items.json'
filesystem = OSFS(text_type(data_dir + '/course_info_updates/info'))
self.assertTrue(filesystem.exists(u'updates.html'))
self.assertTrue(filesystem.exists(u'updates.items.json'))
filesystem = OSFS(str(data_dir + '/course_info_updates/info'))
self.assertTrue(filesystem.exists('updates.html'))
self.assertTrue(filesystem.exists('updates.items.json'))
# verify that course info update module has same data content as in data file from which it is imported
# check 'data' field content
with filesystem.open(u'updates.html', 'r') as course_policy:
with filesystem.open('updates.html', 'r') as course_policy:
on_disk = course_policy.read()
self.assertEqual(course_updates.data, on_disk)
# check 'items' field content
with filesystem.open(u'updates.items.json', 'r') as course_policy:
with filesystem.open('updates.items.json', 'r') as course_policy:
on_disk = loads(course_policy.read())
self.assertEqual(course_updates.items, on_disk)
# now export the course to a tempdir and test that it contains files 'updates.html' and 'updates.items.json'
# with same content as in course 'info' directory
root_dir = path(mkdtemp_clean())
print(u'Exporting to tempdir = {0}'.format(root_dir))
export_course_to_xml(self.store, content_store, course.id, root_dir, u'test_export')
print(f'Exporting to tempdir = {root_dir}')
export_course_to_xml(self.store, content_store, course.id, root_dir, 'test_export')
# check that exported course has files 'updates.html' and 'updates.items.json'
filesystem = OSFS(text_type(root_dir / 'test_export/info'))
self.assertTrue(filesystem.exists(u'updates.html'))
self.assertTrue(filesystem.exists(u'updates.items.json'))
filesystem = OSFS(str(root_dir / 'test_export/info'))
self.assertTrue(filesystem.exists('updates.html'))
self.assertTrue(filesystem.exists('updates.items.json'))
# verify that exported course has same data content as in course_info_update module
with filesystem.open(u'updates.html', 'r') as grading_policy:
with filesystem.open('updates.html', 'r') as grading_policy:
on_disk = grading_policy.read()
self.assertEqual(on_disk, course_updates.data)
with filesystem.open(u'updates.items.json', 'r') as grading_policy:
with filesystem.open('updates.items.json', 'r') as grading_policy:
on_disk = loads(grading_policy.read())
self.assertEqual(on_disk, course_updates.items)
@@ -319,42 +315,42 @@ class ImportRequiredTestCases(ContentStoreTestCase):
course_id = self.import_and_populate_course()
root_dir = path(mkdtemp_clean())
print(u'Exporting to tempdir = {0}'.format(root_dir))
print(f'Exporting to tempdir = {root_dir}')
# export out to a tempdir
export_course_to_xml(self.store, content_store, course_id, root_dir, u'test_export')
export_course_to_xml(self.store, content_store, course_id, root_dir, 'test_export')
# check for static tabs
self.verify_content_existence(self.store, root_dir, course_id, u'tabs', 'static_tab', '.html')
self.verify_content_existence(self.store, root_dir, course_id, 'tabs', 'static_tab', '.html')
# check for about content
self.verify_content_existence(self.store, root_dir, course_id, u'about', 'about', '.html')
self.verify_content_existence(self.store, root_dir, course_id, 'about', 'about', '.html')
# assert that there is an html and video directory in drafts:
draft_dir = OSFS(root_dir / 'test_export/drafts')
self.assertTrue(draft_dir.exists(u'html'))
self.assertTrue(draft_dir.exists(u'video'))
self.assertTrue(draft_dir.exists('html'))
self.assertTrue(draft_dir.exists('video'))
# and assert that they contain the created modules
self.assertIn(self.DRAFT_HTML + ".xml", draft_dir.listdir(u'html'))
self.assertIn(self.DRAFT_VIDEO + ".xml", draft_dir.listdir(u'video'))
self.assertIn(self.DRAFT_HTML + ".xml", draft_dir.listdir('html'))
self.assertIn(self.DRAFT_VIDEO + ".xml", draft_dir.listdir('video'))
# and assert the child of the orphaned draft wasn't exported
self.assertNotIn(self.ORPHAN_DRAFT_HTML + ".xml", draft_dir.listdir(u'html'))
self.assertNotIn(self.ORPHAN_DRAFT_HTML + ".xml", draft_dir.listdir('html'))
# check for grading_policy.json
filesystem = OSFS(root_dir / 'test_export/policies/2012_Fall')
self.assertTrue(filesystem.exists(u'grading_policy.json'))
self.assertTrue(filesystem.exists('grading_policy.json'))
course = self.store.get_course(course_id)
# compare what's on disk compared to what we have in our course
with filesystem.open(u'grading_policy.json', 'r') as grading_policy:
with filesystem.open('grading_policy.json', 'r') as grading_policy:
on_disk = loads(grading_policy.read())
self.assertEqual(on_disk, course.grading_policy)
# check for policy.json
self.assertTrue(filesystem.exists(u'policy.json'))
self.assertTrue(filesystem.exists('policy.json'))
# compare what's on disk to what we have in the course module
with filesystem.open(u'policy.json', 'r') as course_policy:
with filesystem.open('policy.json', 'r') as course_policy:
on_disk = loads(course_policy.read())
self.assertIn('course/2012_Fall', on_disk)
self.assertEqual(on_disk['course/2012_Fall'], own_metadata(course))
@@ -421,10 +417,10 @@ class ImportRequiredTestCases(ContentStoreTestCase):
root_dir = path(mkdtemp_clean())
print(u'Exporting to tempdir = {0}'.format(root_dir))
print(f'Exporting to tempdir = {root_dir}')
# export out to a tempdir
export_course_to_xml(self.store, content_store, course_id, root_dir, u'test_export')
export_course_to_xml(self.store, content_store, course_id, root_dir, 'test_export')
shutil.rmtree(root_dir)
@@ -447,10 +443,10 @@ class ImportRequiredTestCases(ContentStoreTestCase):
root_dir = path(mkdtemp_clean())
print(u'Exporting to tempdir = {0}'.format(root_dir))
print(f'Exporting to tempdir = {root_dir}')
# export out to a tempdir
export_course_to_xml(self.store, content_store, course_id, root_dir, u'test_export')
export_course_to_xml(self.store, content_store, course_id, root_dir, 'test_export')
shutil.rmtree(root_dir)
@@ -503,7 +499,7 @@ class ImportRequiredTestCases(ContentStoreTestCase):
# Export the course
root_dir = path(mkdtemp_clean())
export_course_to_xml(self.store, content_store, course_id, root_dir, u'test_roundtrip')
export_course_to_xml(self.store, content_store, course_id, root_dir, 'test_roundtrip')
# Reimport and get the video back
import_course_from_xml(self.store, self.user.id, root_dir)
@@ -524,7 +520,7 @@ class ImportRequiredTestCases(ContentStoreTestCase):
# Export the course
root_dir = path(mkdtemp_clean())
export_course_to_xml(self.store, content_store, course_id, root_dir, u'test_roundtrip')
export_course_to_xml(self.store, content_store, course_id, root_dir, 'test_roundtrip')
# Reimport and get the video back
import_course_from_xml(self.store, self.user.id, root_dir, create_if_not_present=True)
@@ -547,8 +543,8 @@ class ImportRequiredTestCases(ContentStoreTestCase):
root_dir = path(mkdtemp_clean())
print(u'Exporting to tempdir = {0}'.format(root_dir))
export_course_to_xml(self.store, None, course_id, root_dir, u'test_export_no_content_store')
print(f'Exporting to tempdir = {root_dir}')
export_course_to_xml(self.store, None, course_id, root_dir, 'test_export_no_content_store')
# Delete the course from module store and reimport it
@@ -603,7 +599,7 @@ class ImportRequiredTestCases(ContentStoreTestCase):
content_store,
course_id,
root_dir,
u'test_no_xml_attributes'
'test_no_xml_attributes'
)
@@ -614,7 +610,7 @@ class MiscCourseTests(ContentStoreTestCase):
"""
def setUp(self):
super(MiscCourseTests, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
# save locs not items b/c the items won't have the subsequently created children in them until refetched
self.chapter_loc = self.store.create_child(
self.user.id, self.course.location, 'chapter', 'test_chapter'
@@ -699,7 +695,7 @@ class MiscCourseTests(ContentStoreTestCase):
def test_export_on_invalid_displayname(self, invalid_displayname):
""" Tests that assets with invalid 'displayname' does not cause export to fail """
content_store = contentstore()
exported_asset_name = u'_Fake_asset_displayname'
exported_asset_name = '_Fake_asset_displayname'
# Create an asset with slash `invalid_displayname` '
asset_key = self.course.id.make_asset_key('asset', "fake_asset.txt")
@@ -716,11 +712,11 @@ class MiscCourseTests(ContentStoreTestCase):
# Now export the course to a tempdir and test that it contains assets. The export should pass
root_dir = path(mkdtemp_clean())
print(u'Exporting to tempdir = {0}'.format(root_dir))
export_course_to_xml(self.store, content_store, self.course.id, root_dir, u'test_export')
print(f'Exporting to tempdir = {root_dir}')
export_course_to_xml(self.store, content_store, self.course.id, root_dir, 'test_export')
filesystem = OSFS(root_dir / 'test_export/static')
exported_static_files = filesystem.listdir(u'/')
exported_static_files = filesystem.listdir('/')
# Verify that only single asset has been exported with the expected asset name.
self.assertTrue(filesystem.exists(exported_asset_name))
@@ -741,13 +737,13 @@ class MiscCourseTests(ContentStoreTestCase):
# Make an existing unit a draft
self.store.convert_to_draft(self.problem.location, self.user.id)
root_dir = path(mkdtemp_clean())
export_course_to_xml(self.store, None, self.course.id, root_dir, u'test_export')
export_course_to_xml(self.store, None, self.course.id, root_dir, 'test_export')
# Verify that problem is exported in the drafts. This is expected because we are
# mocking get_item to for drafts. Expect no draft is exported.
# Specifically get_item is used in `xmodule.modulestore.xml_exporter._export_drafts`
export_draft_dir = OSFS(root_dir / 'test_export/drafts')
self.assertEqual(len(export_draft_dir.listdir(u'/')), 0)
self.assertEqual(len(export_draft_dir.listdir('/')), 0)
# Remove tempdir
shutil.rmtree(root_dir)
@@ -755,11 +751,11 @@ class MiscCourseTests(ContentStoreTestCase):
def test_assets_overwrite(self):
""" Tests that assets will similar 'displayname' will be overwritten during export """
content_store = contentstore()
asset_displayname = u'Fake_asset.txt'
asset_displayname = 'Fake_asset.txt'
# Create two assets with similar 'displayname'
for i in range(2):
asset_path = 'sample_asset_{}.txt'.format(i)
asset_path = f'sample_asset_{i}.txt'
asset_key = self.course.id.make_asset_key('asset', asset_path)
content = StaticContent(
asset_key, asset_displayname, 'application/text', b'test',
@@ -776,12 +772,12 @@ class MiscCourseTests(ContentStoreTestCase):
# Now export the course to a tempdir and test that it contains assets.
root_dir = path(mkdtemp_clean())
print(u'Exporting to tempdir = {0}'.format(root_dir))
export_course_to_xml(self.store, content_store, self.course.id, root_dir, u'test_export')
print(f'Exporting to tempdir = {root_dir}')
export_course_to_xml(self.store, content_store, self.course.id, root_dir, 'test_export')
# Verify that asset have been overwritten during export.
filesystem = OSFS(root_dir / 'test_export/static')
exported_static_files = filesystem.listdir(u'/')
exported_static_files = filesystem.listdir('/')
self.assertTrue(filesystem.exists(asset_displayname))
self.assertEqual(len(exported_static_files), 1)
@@ -938,7 +934,7 @@ class MiscCourseTests(ContentStoreTestCase):
"""
Tests the ajax callback to render an XModule
"""
with override_settings(COURSES_WITH_UNSAFE_CODE=[text_type(self.course.id)]):
with override_settings(COURSES_WITH_UNSAFE_CODE=[str(self.course.id)]):
# also try a custom response which will trigger the 'is this course in whitelist' logic
resp = self.client.get_json(
get_url('xblock_view_handler', self.vert_loc, kwargs={'view_name': 'container_preview'})
@@ -947,7 +943,7 @@ class MiscCourseTests(ContentStoreTestCase):
vertical = self.store.get_item(self.vert_loc)
for child in vertical.children:
self.assertContains(resp, text_type(child))
self.assertContains(resp, str(child))
def test_delete(self):
# make sure the parent points to the child object which is to be deleted
@@ -980,7 +976,7 @@ class MiscCourseTests(ContentStoreTestCase):
self.assertIsNotNone(content)
# let's restore the asset
restore_asset_from_trashcan(text_type(asset_key))
restore_asset_from_trashcan(str(asset_key))
# now try to find it in courseware store, and they should be back after restore
content = contentstore('trashcan').find(asset_key, throw_on_not_found=False)
@@ -1004,7 +1000,7 @@ class MiscCourseTests(ContentStoreTestCase):
url = reverse_course_url(
'assets_handler',
self.course.id,
kwargs={'asset_key_string': text_type(asset_key)}
kwargs={'asset_key_string': str(asset_key)}
)
resp = self.client.delete(url)
self.assertEqual(resp.status_code, 204)
@@ -1061,7 +1057,7 @@ class MiscCourseTests(ContentStoreTestCase):
self.assertEqual(resp.status_code, 404)
@override_switch(
'{}.{}'.format(waffle.WAFFLE_NAMESPACE, waffle.ENABLE_ACCESSIBILITY_POLICY_PAGE),
f'{waffle.WAFFLE_NAMESPACE}.{waffle.ENABLE_ACCESSIBILITY_POLICY_PAGE}',
active=False)
def test_disabled_accessibility_page(self):
"""
@@ -1118,7 +1114,7 @@ class MiscCourseTests(ContentStoreTestCase):
# check that /static/ has been converted to the full path
# note, we know the link it should be because that's what in the 'toy' course in the test data
asset_key = self.course.id.make_asset_key('asset', 'handouts_sample_handout.txt')
self.assertContains(resp, text_type(asset_key))
self.assertContains(resp, str(asset_key))
def test_prefetch_children(self):
# make sure we haven't done too many round trips to DB:
@@ -1161,7 +1157,7 @@ class ContentStoreTest(ContentStoreTestCase):
"Please change either organization or course number to be unique.")
def setUp(self):
super(ContentStoreTest, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.course_data = {
'org': 'MITx',
@@ -1177,7 +1173,7 @@ class ContentStoreTest(ContentStoreTestCase):
test_course_data = {}
test_course_data.update(self.course_data)
if number_suffix:
test_course_data['number'] = '{0}_{1}'.format(test_course_data['number'], number_suffix)
test_course_data['number'] = '{}_{}'.format(test_course_data['number'], number_suffix)
course_key = _get_course_id(self.store, test_course_data)
_create_course(self, course_key, test_course_data)
# Verify that the creator is now registered in the course.
@@ -1451,13 +1447,13 @@ class ContentStoreTest(ContentStoreTestCase):
"""
with mock.patch.dict('django.conf.settings.FEATURES', {'ALLOW_UNICODE_COURSE_ID': False}):
error_message = "Special characters not allowed in organization, course number, and course run."
self.course_data['org'] = u'<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>'
self.course_data['org'] = '<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>'
self.assert_create_course_failed(error_message)
self.course_data['number'] = u'<EFBFBD><EFBFBD>chantillon'
self.course_data['number'] = '<EFBFBD><EFBFBD>chantillon'
self.assert_create_course_failed(error_message)
self.course_data['run'] = u'<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>'
self.course_data['run'] = '<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>'
self.assert_create_course_failed(error_message)
def assert_course_permission_denied(self):
@@ -1472,7 +1468,7 @@ class ContentStoreTest(ContentStoreTestCase):
resp = self.client.get_html('/home/')
self.assertContains(
resp,
u'<h1 class="page-header">{} Home</h1>'.format(settings.STUDIO_SHORT_NAME),
f'<h1 class="page-header">{settings.STUDIO_SHORT_NAME} Home</h1>',
status_code=200,
html=True
)
@@ -1495,8 +1491,8 @@ class ContentStoreTest(ContentStoreTestCase):
self.assertContains(
resp,
'<article class="outline outline-complex outline-course" data-locator="{locator}" data-course-key="{course_key}">'.format( # lint-amnesty, pylint: disable=line-too-long
locator=text_type(course.location),
course_key=text_type(course.id),
locator=str(course.location),
course_key=str(course.id),
),
status_code=200,
html=True
@@ -1507,7 +1503,7 @@ class ContentStoreTest(ContentStoreTestCase):
course = CourseFactory.create()
section_data = {
'parent_locator': text_type(course.location),
'parent_locator': str(course.location),
'category': 'chapter',
'display_name': 'Section One',
}
@@ -1516,7 +1512,7 @@ class ContentStoreTest(ContentStoreTestCase):
self.assertEqual(resp.status_code, 200)
data = parse_json(resp)
retarget = text_type(course.id.make_usage_key('chapter', 'REPLACE')).replace('REPLACE', r'([0-9]|[a-f]){3,}')
retarget = str(course.id.make_usage_key('chapter', 'REPLACE')).replace('REPLACE', r'([0-9]|[a-f]){3,}')
self.assertRegex(data['locator'], retarget)
def test_capa_module(self):
@@ -1524,7 +1520,7 @@ class ContentStoreTest(ContentStoreTestCase):
course = CourseFactory.create()
problem_data = {
'parent_locator': text_type(course.location),
'parent_locator': str(course.location),
'category': 'problem'
}
@@ -1806,7 +1802,7 @@ class MetadataSaveTestCase(ContentStoreTestCase):
"""Test that metadata is correctly cached and decached."""
def setUp(self):
super(MetadataSaveTestCase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
course = CourseFactory.create()
@@ -1866,7 +1862,7 @@ class RerunCourseTest(ContentStoreTestCase):
"""
def setUp(self):
super(RerunCourseTest, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.destination_course_data = {
'org': 'MITx',
'number': '111',
@@ -1880,7 +1876,7 @@ class RerunCourseTest(ContentStoreTestCase):
"""Create and send an ajax post for the rerun request"""
# create data to post
rerun_course_data = {'source_course_key': text_type(source_course_key)}
rerun_course_data = {'source_course_key': str(source_course_key)}
if not destination_course_data:
destination_course_data = self.destination_course_data
rerun_course_data.update(destination_course_data)
@@ -1900,7 +1896,7 @@ class RerunCourseTest(ContentStoreTestCase):
def get_unsucceeded_course_action_elements(self, html, course_key):
"""Returns the elements in the unsucceeded course action section that have the given course_key"""
return html.cssselect(u'.courses-processing li[data-course-key="{}"]'.format(text_type(course_key)))
return html.cssselect('.courses-processing li[data-course-key="{}"]'.format(str(course_key)))
def assertInCourseListing(self, course_key):
"""
@@ -1928,7 +1924,7 @@ class RerunCourseTest(ContentStoreTestCase):
'course_key': destination_course_key,
'should_display': True,
}
for field_name, expected_value in six.iteritems(expected_states):
for field_name, expected_value in expected_states.items():
self.assertEqual(getattr(rerun_state, field_name), expected_value)
# Verify that the creator is now enrolled in the course.
@@ -1945,7 +1941,7 @@ class RerunCourseTest(ContentStoreTestCase):
source_course = CourseFactory.create()
destination_course_key = self.post_rerun_request(source_course.id)
self.verify_rerun_course(source_course.id, destination_course_key, self.destination_course_data['display_name'])
videos, __ = get_videos_for_course(text_type(destination_course_key))
videos, __ = get_videos_for_course(str(destination_course_key))
videos = list(videos)
self.assertEqual(0, len(videos))
self.assertInCourseListing(destination_course_key)
@@ -1972,7 +1968,7 @@ class RerunCourseTest(ContentStoreTestCase):
create_video(
dict(
edx_video_id="tree-hugger",
courses=[text_type(source_course.id)],
courses=[str(source_course.id)],
status='test',
duration=2,
encoded_videos=[]
@@ -1982,9 +1978,9 @@ class RerunCourseTest(ContentStoreTestCase):
self.verify_rerun_course(source_course.id, destination_course_key, self.destination_course_data['display_name'])
# Verify that the VAL copies videos to the rerun
videos, __ = get_videos_for_course(text_type(source_course.id))
videos, __ = get_videos_for_course(str(source_course.id))
source_videos = list(videos)
videos, __ = get_videos_for_course(text_type(destination_course_key))
videos, __ = get_videos_for_course(str(destination_course_key))
target_videos = list(videos)
self.assertEqual(1, len(source_videos))
self.assertEqual(source_videos, target_videos)
@@ -2101,7 +2097,7 @@ class RerunCourseTest(ContentStoreTestCase):
'run': '2013'
}
source_wiki_slug = '{0}.{1}.{2}'.format(course_data['org'], course_data['number'], course_data['run'])
source_wiki_slug = '{}.{}.{}'.format(course_data['org'], course_data['number'], course_data['run'])
source_course_key = _get_course_id(self.store, course_data)
_create_course(self, source_course_key, course_data)
@@ -2119,7 +2115,7 @@ class RerunCourseTest(ContentStoreTestCase):
self.verify_rerun_course(source_course.id, destination_course_key, destination_course_data['display_name'])
destination_course = self.store.get_course(destination_course_key)
destination_wiki_slug = '{0}.{1}.{2}'.format(
destination_wiki_slug = '{}.{}.{}'.format(
destination_course.id.org, destination_course.id.course, destination_course.id.run
)
@@ -2137,8 +2133,8 @@ class ContentLicenseTest(ContentStoreTestCase):
root_dir = path(mkdtemp_clean())
self.course.license = "creative-commons: BY SA"
self.store.update_item(self.course, None)
export_course_to_xml(self.store, content_store, self.course.id, root_dir, u'test_license')
fname = "{block}.xml".format(block=self.course.scope_ids.usage_id.block_id)
export_course_to_xml(self.store, content_store, self.course.id, root_dir, 'test_license')
fname = f"{self.course.scope_ids.usage_id.block_id}.xml"
run_file_path = root_dir / "test_license" / "course" / fname
with run_file_path.open() as f:
run_xml = etree.parse(f)
@@ -2151,8 +2147,8 @@ class ContentLicenseTest(ContentStoreTestCase):
parent_location=self.course.location, category='video',
license="all-rights-reserved"
)
export_course_to_xml(self.store, content_store, self.course.id, root_dir, u'test_license')
fname = "{block}.xml".format(block=video_descriptor.scope_ids.usage_id.block_id)
export_course_to_xml(self.store, content_store, self.course.id, root_dir, 'test_license')
fname = f"{video_descriptor.scope_ids.usage_id.block_id}.xml"
video_file_path = root_dir / "test_license" / "video" / fname
with video_file_path.open() as f:
video_xml = etree.parse(f)
@@ -2174,7 +2170,7 @@ class EntryPageTestCase(TestCase):
"""
def setUp(self):
super(EntryPageTestCase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.client = AjaxEnabledTestClient()
def _test_page(self, page, status_code=200):
@@ -2197,7 +2193,7 @@ class EntryPageTestCase(TestCase):
self._test_page("/logout", 200)
@override_switch(
'{}.{}'.format(waffle.WAFFLE_NAMESPACE, waffle.ENABLE_ACCESSIBILITY_POLICY_PAGE),
f'{waffle.WAFFLE_NAMESPACE}.{waffle.ENABLE_ACCESSIBILITY_POLICY_PAGE}',
active=True)
def test_accessibility(self):
self._test_page('/accessibility')

6
cms/djangoapps/contentstore/tests/test_core_caching.py
View File

@@ -9,7 +9,7 @@ from opaque_keys.edx.locator import AssetLocator, CourseLocator
from openedx.core.djangoapps.contentserver.caching import del_cached_content, get_cached_content, set_cached_content
class Content(object):
class Content:
"""
Mock cached content
"""
@@ -25,9 +25,9 @@ class CachingTestCase(TestCase):
"""
Tests for https://edx.lighthouseapp.com/projects/102637/tickets/112-updating-asset-does-not-refresh-the-cached-copy
"""
unicodeLocation = AssetLocator(CourseLocator(u'c4x', u'mitX', u'800'), u'thumbnail', u'monsters.jpg')
unicodeLocation = AssetLocator(CourseLocator('c4x', 'mitX', '800'), 'thumbnail', 'monsters.jpg')
# Note that some of the parts are strings instead of unicode strings
nonUnicodeLocation = AssetLocator(CourseLocator('c4x', u'mitX', u'800'), 'thumbnail', 'monsters.jpg')
nonUnicodeLocation = AssetLocator(CourseLocator('c4x', 'mitX', '800'), 'thumbnail', 'monsters.jpg')
mockAsset = Content(unicodeLocation, 'my content')
def test_put_and_get(self):

13
cms/djangoapps/contentstore/tests/test_course_create_rerun.py
View File

@@ -6,16 +6,11 @@ Test view handler for rerun (and eventually create)
import datetime
import ddt
import six
from django.test import override_settings
from django.test.client import RequestFactory
from django.urls import reverse
from opaque_keys.edx.keys import CourseKey
from organizations.api import (
add_organization,
get_organization_by_short_name,
get_course_organizations
)
from organizations.api import add_organization, get_course_organizations, get_organization_by_short_name
from organizations.exceptions import InvalidOrganizationException
from cms.djangoapps.contentstore.tests.utils import AjaxEnabledTestClient, parse_json
@@ -37,7 +32,7 @@ class TestCourseListing(ModuleStoreTestCase):
"""
Add a user and a course
"""
super(TestCourseListing, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
# create and log in a staff user.
# create and log in a non-staff user
self.user = UserFactory()
@@ -81,7 +76,7 @@ class TestCourseListing(ModuleStoreTestCase):
'description': 'Testing Organization Description',
})
response = self.client.ajax_post(self.course_create_rerun_url, {
'source_course_key': six.text_type(self.source_course_key),
'source_course_key': str(self.source_course_key),
'org': self.source_course_key.org, 'course': self.source_course_key.course, 'run': 'copy',
'display_name': 'not the same old name',
})
@@ -160,7 +155,7 @@ class TestCourseListing(ModuleStoreTestCase):
with self.assertRaises(InvalidOrganizationException):
get_organization_by_short_name("orgX")
data = parse_json(response)
self.assertIn(u'Organization you selected does not exist in the system', data['error'])
self.assertIn('Organization you selected does not exist in the system', data['error'])
@ddt.data(True, False)
def test_course_creation_for_known_organization(self, organizations_autocreate):

15
cms/djangoapps/contentstore/tests/test_course_listing.py
View File

@@ -5,14 +5,13 @@ by reversing group name formats.
import random
from unittest.mock import Mock, patch
import ddt
from ccx_keys.locator import CCXLocator
from django.conf import settings
from django.test import RequestFactory
from mock import Mock, patch
from opaque_keys.edx.locations import CourseLocator
from six.moves import range
from cms.djangoapps.contentstore.tests.utils import AjaxEnabledTestClient
from cms.djangoapps.contentstore.utils import delete_course
@@ -51,7 +50,7 @@ class TestCourseListing(ModuleStoreTestCase):
"""
Add a user and a course
"""
super(TestCourseListing, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
# create and log in a staff user.
# create and log in a non-staff user
self.user = UserFactory()
@@ -91,7 +90,7 @@ class TestCourseListing(ModuleStoreTestCase):
"""
Test on empty course listing, studio name is properly displayed
"""
message = u"Are you staff on an existing {studio_name} course?".format(studio_name=settings.STUDIO_SHORT_NAME)
message = f"Are you staff on an existing {settings.STUDIO_SHORT_NAME} course?"
response = self.client.get('/home')
self.assertContains(response, message)
@@ -256,9 +255,9 @@ class TestCourseListing(ModuleStoreTestCase):
# create courses and assign those to the user which have their number in user_course_ids
with self.store.default_store(store):
for number in range(TOTAL_COURSES_COUNT):
org = 'Org{0}'.format(number)
course = 'Course{0}'.format(number)
run = 'Run{0}'.format(number)
org = f'Org{number}'
course = f'Course{number}'
run = f'Run{number}'
course_location = self.store.make_course_key(org, course, run)
if number in user_course_ids:
self._create_course_with_access_groups(course_location, self.user, store=store)
@@ -369,7 +368,7 @@ class TestCourseListing(ModuleStoreTestCase):
# verify return values
def _set_of_course_keys(course_list, key_attribute_name='id'):
"""Returns a python set of course keys by accessing the key with the given attribute name."""
return set(getattr(c, key_attribute_name) for c in course_list)
return {getattr(c, key_attribute_name) for c in course_list}
found_courses, unsucceeded_course_actions = _accessible_courses_iter_for_tests(self.request)
self.assertSetEqual(_set_of_course_keys(courses + courses_in_progress), _set_of_course_keys(found_courses))

51
cms/djangoapps/contentstore/tests/test_course_settings.py
View File

@@ -7,10 +7,10 @@ import copy
import datetime
import json
import unittest
from unittest import mock
from unittest.mock import Mock, patch
import ddt
import mock
import six
from crum import set_current_request
from django.conf import settings
from django.test import RequestFactory
@@ -18,7 +18,6 @@ from django.test.utils import override_settings
from edx_toggles.toggles.testutils import override_waffle_flag
from milestones.models import MilestoneRelationshipType
from milestones.tests.utils import MilestonesTestCaseMixin
from mock import Mock, patch
from pytz import UTC
from cms.djangoapps.contentstore.utils import reverse_course_url, reverse_usage_url
@@ -31,11 +30,11 @@ from cms.djangoapps.models.settings.course_metadata import CourseMetadata
from cms.djangoapps.models.settings.encoder import CourseSettingsEncoder
from cms.djangoapps.models.settings.waffle import MATERIAL_RECOMPUTE_ONLY_FLAG
from common.djangoapps.course_modes.models import CourseMode
from openedx.core.djangoapps.models.course_details import CourseDetails
from common.djangoapps.student.roles import CourseInstructorRole, CourseStaffRole
from common.djangoapps.student.tests.factories import UserFactory
from common.djangoapps.util import milestones_helpers
from common.djangoapps.xblock_django.models import XBlockStudioConfigurationFlag
from openedx.core.djangoapps.models.course_details import CourseDetails
from xmodule.fields import Date
from xmodule.modulestore import ModuleStoreEnum
from xmodule.modulestore.django import modulestore
@@ -100,7 +99,7 @@ class CourseAdvanceSettingViewTest(CourseTestCase, MilestonesTestCaseMixin):
"""
def setUp(self):
super(CourseAdvanceSettingViewTest, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.fullcourse = CourseFactory.create()
self.course_setting_url = get_url(self.course.id, 'advanced_settings_handler')
@@ -204,7 +203,7 @@ class CourseDetailsViewTest(CourseTestCase, MilestonesTestCaseMixin):
dt1 = date.from_json(encoded[field])
dt2 = details[field]
self.assertEqual(dt1, dt2, msg=u"{} != {} at {}".format(dt1, dt2, context))
self.assertEqual(dt1, dt2, msg=f"{dt1} != {dt2} at {context}")
else:
self.fail(field + " missing from encoded but in details at " + context)
elif field in encoded and encoded[field] is not None:
@@ -253,7 +252,7 @@ class CourseDetailsViewTest(CourseTestCase, MilestonesTestCaseMixin):
# update pre requisite courses with a new course keys
pre_requisite_course = CourseFactory.create(org='edX', course='900', run='test_run')
pre_requisite_course2 = CourseFactory.create(org='edX', course='902', run='test_run')
pre_requisite_course_keys = [six.text_type(pre_requisite_course.id), six.text_type(pre_requisite_course2.id)]
pre_requisite_course_keys = [str(pre_requisite_course.id), str(pre_requisite_course2.id)]
course_detail_json['pre_requisite_courses'] = pre_requisite_course_keys
self.client.ajax_post(url, course_detail_json)
@@ -283,7 +282,7 @@ class CourseDetailsViewTest(CourseTestCase, MilestonesTestCaseMixin):
# update pre requisite courses one valid and one invalid key
pre_requisite_course = CourseFactory.create(org='edX', course='900', run='test_run')
pre_requisite_course_keys = [six.text_type(pre_requisite_course.id), 'invalid_key']
pre_requisite_course_keys = [str(pre_requisite_course.id), 'invalid_key']
course_detail_json['pre_requisite_courses'] = pre_requisite_course_keys
response = self.client.ajax_post(url, course_detail_json)
self.assertEqual(400, response.status_code)
@@ -564,10 +563,10 @@ class CourseGradingTest(CourseTestCase):
mock.call(
GRADING_POLICY_CHANGED_EVENT_TYPE,
{
'course_id': six.text_type(self.course.id),
'course_id': str(self.course.id),
'event_transaction_type': 'edx.grades.grading_policy_changed',
'grading_policy_hash': policy_hash,
'user_id': six.text_type(self.user.id),
'user_id': str(self.user.id),
'event_transaction_id': 'mockUUID',
}
) for policy_hash in (
@@ -687,8 +686,8 @@ class CourseGradingTest(CourseTestCase):
mock.call(
GRADING_POLICY_CHANGED_EVENT_TYPE,
{
'course_id': six.text_type(self.course.id),
'user_id': six.text_type(self.user.id),
'course_id': str(self.course.id),
'user_id': str(self.user.id),
'grading_policy_hash': policy_hash,
'event_transaction_id': 'mockUUID',
'event_transaction_type': 'edx.grades.grading_policy_changed',
@@ -725,10 +724,10 @@ class CourseGradingTest(CourseTestCase):
mock.call(
GRADING_POLICY_CHANGED_EVENT_TYPE,
{
'course_id': six.text_type(self.course.id),
'course_id': str(self.course.id),
'event_transaction_type': 'edx.grades.grading_policy_changed',
'grading_policy_hash': policy_hash,
'user_id': six.text_type(self.user.id),
'user_id': str(self.user.id),
'event_transaction_id': 'mockUUID',
}
) for policy_hash in (grading_policy_1, grading_policy_2, grading_policy_3)
@@ -802,10 +801,10 @@ class CourseGradingTest(CourseTestCase):
mock.call(
GRADING_POLICY_CHANGED_EVENT_TYPE,
{
'course_id': six.text_type(self.course.id),
'course_id': str(self.course.id),
'event_transaction_type': 'edx.grades.grading_policy_changed',
'grading_policy_hash': policy_hash,
'user_id': six.text_type(self.user.id),
'user_id': str(self.user.id),
'event_transaction_id': 'mockUUID',
}
) for policy_hash in (grading_policy_1, grading_policy_2)
@@ -895,15 +894,15 @@ class CourseGradingTest(CourseTestCase):
Test setting and getting section grades via the grade as url
"""
grade_type_url = self.setup_test_set_get_section_grader_ajax()
response = self.client.ajax_post(grade_type_url, {'graderType': u'Homework'})
response = self.client.ajax_post(grade_type_url, {'graderType': 'Homework'})
self.assertEqual(200, response.status_code)
response = self.client.get_json(grade_type_url + '?fields=graderType')
self.assertEqual(json.loads(response.content.decode('utf-8')).get('graderType'), u'Homework')
self.assertEqual(json.loads(response.content.decode('utf-8')).get('graderType'), 'Homework')
# and unset
response = self.client.ajax_post(grade_type_url, {'graderType': u'notgraded'})
response = self.client.ajax_post(grade_type_url, {'graderType': 'notgraded'})
self.assertEqual(200, response.status_code)
response = self.client.get_json(grade_type_url + '?fields=graderType')
self.assertEqual(json.loads(response.content.decode('utf-8')).get('graderType'), u'notgraded')
self.assertEqual(json.loads(response.content.decode('utf-8')).get('graderType'), 'notgraded')
def _grading_policy_hash_for_course(self):
return hash_grading_policy(modulestore().get_course(self.course.id).grading_policy)
@@ -916,7 +915,7 @@ class CourseMetadataEditingTest(CourseTestCase):
"""
def setUp(self):
super(CourseMetadataEditingTest, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.fullcourse = CourseFactory.create()
self.course_setting_url = get_url(self.course.id, 'advanced_settings_handler')
self.fullcourse_setting_url = get_url(self.fullcourse.id, 'advanced_settings_handler')
@@ -1175,8 +1174,8 @@ class CourseMetadataEditingTest(CourseTestCase):
self.assertEqual(len(errors), 3)
self.assertFalse(test_model)
error_keys = set([error_obj['model']['display_name'] for error_obj in errors]) # lint-amnesty, pylint: disable=consider-using-set-comprehension
test_keys = set(['Advanced Module List', 'Course Advertised Start Date', 'Days Early for Beta Users'])
error_keys = {error_obj['model']['display_name'] for error_obj in errors}
test_keys = {'Advanced Module List', 'Course Advertised Start Date', 'Days Early for Beta Users'}
self.assertEqual(error_keys, test_keys)
# try fresh fetch to ensure no update happened
@@ -1527,7 +1526,7 @@ class CourseGraderUpdatesTest(CourseTestCase):
def setUp(self):
"""Compute the url to use in tests"""
super(CourseGraderUpdatesTest, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.url = get_url(self.course.id, 'grading_handler')
self.starting_graders = CourseGradingModel(self.course).graders
@@ -1625,9 +1624,9 @@ id=\"course-enrollment-end-time\" value=\"\" placeholder=\"HH:MM\" autocomplete=
"""
Initialize course used to test enrollment fields.
"""
super(CourseEnrollmentEndFieldTest, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.course = CourseFactory.create(org='edX', number='dummy', display_name='Marketing Site Course')
self.course_details_url = reverse_course_url('settings_handler', six.text_type(self.course.id))
self.course_details_url = reverse_course_url('settings_handler', str(self.course.id))
def _get_course_details_response(self, global_staff):
"""

132
cms/djangoapps/contentstore/tests/test_courseware_index.py
View File

@@ -7,17 +7,15 @@ import json
import time
from datetime import datetime
from unittest import skip
from unittest.mock import patch
from uuid import uuid4
import ddt
import pytest
import six
from django.conf import settings
from lazy.lazy import lazy
from mock import patch
from pytz import UTC
from search.search_engine_base import SearchEngine
from six.moves import range
from xblock.core import XBlock # lint-amnesty, pylint: disable=unused-import
from cms.djangoapps.contentstore.courseware_index import (
@@ -71,7 +69,7 @@ def create_children(store, parent, category, load_factor):
child_object = ItemFactory.create(
parent_location=parent.location,
category=category,
display_name=u"{} {} {}".format(category, child_index, time.clock()), # lint-amnesty, pylint: disable=no-member
display_name=f"{category} {child_index} {time.clock()}", # lint-amnesty, pylint: disable=no-member
modulestore=store,
publish_item=True,
start=datetime(2015, 3, 1, tzinfo=UTC),
@@ -195,7 +193,7 @@ class TestCoursewareSearchIndexer(MixedWithOptionsTestCase):
WORKS_WITH_STORES = (ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
def setUp(self):
super(TestCoursewareSearchIndexer, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.course = None
self.chapter = None
@@ -263,7 +261,7 @@ class TestCoursewareSearchIndexer(MixedWithOptionsTestCase):
)
def _get_default_search(self):
return {"course": six.text_type(self.course.id)}
return {"course": str(self.course.id)}
def _test_indexing_course(self, store):
""" indexing course tests """
@@ -361,10 +359,10 @@ class TestCoursewareSearchIndexer(MixedWithOptionsTestCase):
results = response["results"]
date_map = {
six.text_type(self.chapter.location): early_date,
six.text_type(self.sequential.location): early_date,
six.text_type(self.vertical.location): later_date,
six.text_type(self.html_unit.location): later_date,
str(self.chapter.location): early_date,
str(self.sequential.location): early_date,
str(self.vertical.location): later_date,
str(self.html_unit.location): later_date,
}
for result in results:
self.assertEqual(result["data"]["start_date"], date_map[result["data"]["id"]])
@@ -429,7 +427,7 @@ class TestCoursewareSearchIndexer(MixedWithOptionsTestCase):
self.update_item(store, self.course)
self.reindex_course(store)
response = self.searcher.search(
field_dictionary={"course": six.text_type(self.course.id)}
field_dictionary={"course": str(self.course.id)}
)
self.assertEqual(response["total"], 1)
self.assertEqual(response["results"][0]["data"]["content"]["display_name"], display_name)
@@ -446,7 +444,7 @@ class TestCoursewareSearchIndexer(MixedWithOptionsTestCase):
)
self.reindex_course(store)
response = self.searcher.search(
field_dictionary={"course": six.text_type(self.course.id)}
field_dictionary={"course": str(self.course.id)}
)
self.assertEqual(response["total"], 1)
self.assertEqual(response["results"][0]["data"]["content"]["short_description"], short_description)
@@ -473,7 +471,7 @@ class TestCoursewareSearchIndexer(MixedWithOptionsTestCase):
self.reindex_course(store)
response = self.searcher.search(
field_dictionary={"course": six.text_type(self.course.id)}
field_dictionary={"course": str(self.course.id)}
)
self.assertEqual(response["total"], 1)
self.assertIn(CourseMode.HONOR, response["results"][0]["data"]["modes"])
@@ -605,11 +603,11 @@ class TestLargeCourseDeletions(MixedWithOptionsTestCase):
self.course_id = None
def setUp(self):
super(TestLargeCourseDeletions, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.course_id = None
def tearDown(self):
super(TestLargeCourseDeletions, self).tearDown() # lint-amnesty, pylint: disable=super-with-arguments
super().tearDown()
self._clean_course_id()
def assert_search_count(self, expected_count):
@@ -622,13 +620,13 @@ class TestLargeCourseDeletions(MixedWithOptionsTestCase):
""" Test that deleting items from a course works even when present within a very large course """
def id_list(top_parent_object):
""" private function to get ids from object down the tree """
list_of_ids = [six.text_type(top_parent_object.location)]
list_of_ids = [str(top_parent_object.location)]
for child in top_parent_object.get_children():
list_of_ids.extend(id_list(child))
return list_of_ids
course, course_size = create_large_course(store, load_factor)
self.course_id = six.text_type(course.id)
self.course_id = str(course.id)
# index full course
CoursewareSearchIndexer.do_course_reindex(store, course.id)
@@ -657,10 +655,10 @@ class TestLargeCourseDeletions(MixedWithOptionsTestCase):
self._do_test_large_course_deletion(store, load_factor)
except: # pylint: disable=bare-except
# Catch any exception here to see when we fail
print(u"Failed with load_factor of {}".format(load_factor))
print(f"Failed with load_factor of {load_factor}")
@skip(("This test is to see how we handle very large courses, to ensure that the delete"
"procedure works smoothly - too long to run during the normal course of things"))
@skip("This test is to see how we handle very large courses, to ensure that the delete"
"procedure works smoothly - too long to run during the normal course of things")
@ddt.data(*WORKS_WITH_STORES)
def test_large_course_deletion(self, store_type):
self._perform_test_using_store(store_type, self._test_large_course_deletion)
@@ -676,7 +674,7 @@ class TestTaskExecution(SharedModuleStoreTestCase):
@classmethod
def setUpClass(cls):
super(TestTaskExecution, cls).setUpClass()
super().setUpClass()
SignalHandler.course_published.disconnect(listen_for_course_publish)
SignalHandler.library_updated.disconnect(listen_for_library_update)
cls.course = CourseFactory.create(start=datetime(2015, 3, 1, tzinfo=UTC))
@@ -730,7 +728,7 @@ class TestTaskExecution(SharedModuleStoreTestCase):
def tearDownClass(cls):
SignalHandler.course_published.connect(listen_for_course_publish)
SignalHandler.library_updated.connect(listen_for_library_update)
super(TestTaskExecution, cls).tearDownClass()
super().tearDownClass()
def test_task_indexing_course(self):
"""
@@ -739,7 +737,7 @@ class TestTaskExecution(SharedModuleStoreTestCase):
"""
searcher = SearchEngine.get_search_engine(CoursewareSearchIndexer.INDEX_NAME)
response = searcher.search(
field_dictionary={"course": six.text_type(self.course.id)}
field_dictionary={"course": str(self.course.id)}
)
self.assertEqual(response["total"], 0)
@@ -747,14 +745,14 @@ class TestTaskExecution(SharedModuleStoreTestCase):
# Note that this test will only succeed if celery is working in inline mode
response = searcher.search(
field_dictionary={"course": six.text_type(self.course.id)}
field_dictionary={"course": str(self.course.id)}
)
self.assertEqual(response["total"], 3)
def test_task_library_update(self):
""" Making sure that the receiver correctly fires off the task when invoked by signal """
searcher = SearchEngine.get_search_engine(LibrarySearchIndexer.INDEX_NAME)
library_search_key = six.text_type(normalize_key_for_search(self.library.location.library_key))
library_search_key = str(normalize_key_for_search(self.library.location.library_key))
response = searcher.search(field_dictionary={"library": library_search_key})
self.assertEqual(response["total"], 0)
@@ -787,7 +785,7 @@ class TestLibrarySearchIndexer(MixedWithOptionsTestCase):
WORKS_WITH_STORES = (ModuleStoreEnum.Type.split, )
def setUp(self):
super(TestLibrarySearchIndexer, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.library = None
self.html_unit1 = None
@@ -819,7 +817,7 @@ class TestLibrarySearchIndexer(MixedWithOptionsTestCase):
def _get_default_search(self):
""" Returns field_dictionary for default search """
return {"library": six.text_type(self.library.location.library_key.replace(version_guid=None, branch=None))}
return {"library": str(self.library.location.library_key.replace(version_guid=None, branch=None))}
def reindex_library(self, store):
""" kick off complete reindex of the course """
@@ -937,7 +935,7 @@ class GroupConfigurationSearchMongo(CourseTestCase, MixedWithOptionsTestCase):
INDEX_NAME = CoursewareSearchIndexer.INDEX_NAME
def setUp(self):
super(GroupConfigurationSearchMongo, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self._setup_course_with_content()
self._setup_split_test_module()
@@ -1099,26 +1097,26 @@ class GroupConfigurationSearchMongo(CourseTestCase, MixedWithOptionsTestCase):
Set up cohort and experiment content groups.
"""
cohort_groups_list = {
u'id': 666,
u'name': u'Test name',
u'scheme': u'cohort',
u'description': u'Test description',
u'version': UserPartition.VERSION,
u'groups': [
{u'id': 0, u'name': u'Group A', u'version': 1, u'usage': []},
{u'id': 1, u'name': u'Group B', u'version': 1, u'usage': []},
'id': 666,
'name': 'Test name',
'scheme': 'cohort',
'description': 'Test description',
'version': UserPartition.VERSION,
'groups': [
{'id': 0, 'name': 'Group A', 'version': 1, 'usage': []},
{'id': 1, 'name': 'Group B', 'version': 1, 'usage': []},
],
}
experiment_groups_list = {
u'id': 0,
u'name': u'Experiment aware partition',
u'scheme': u'random',
u'description': u'Experiment aware description',
u'version': UserPartition.VERSION,
u'groups': [
{u'id': 2, u'name': u'Group A', u'version': 1, u'usage': []},
{u'id': 3, u'name': u'Group B', u'version': 1, u'usage': []},
{u'id': 4, u'name': u'Group C', u'version': 1, u'usage': []}
'id': 0,
'name': 'Experiment aware partition',
'scheme': 'random',
'description': 'Experiment aware description',
'version': UserPartition.VERSION,
'groups': [
{'id': 2, 'name': 'Group A', 'version': 1, 'usage': []},
{'id': 3, 'name': 'Group B', 'version': 1, 'usage': []},
{'id': 4, 'name': 'Group C', 'version': 1, 'usage': []}
],
}
@@ -1153,9 +1151,9 @@ class GroupConfigurationSearchMongo(CourseTestCase, MixedWithOptionsTestCase):
"""
return {
'course_name': self.course.display_name,
'id': six.text_type(html_unit.location),
'id': str(html_unit.location),
'content': {'html_content': '', 'display_name': html_unit.display_name},
'course': six.text_type(self.course.id),
'course': str(self.course.id),
'location': [
self.chapter.display_name,
self.sequential.display_name,
@@ -1173,9 +1171,9 @@ class GroupConfigurationSearchMongo(CourseTestCase, MixedWithOptionsTestCase):
"""
return {
'course_name': self.course.display_name,
'id': six.text_type(html_unit.location),
'id': str(html_unit.location),
'content': {'html_content': '', 'display_name': html_unit.display_name},
'course': six.text_type(self.course.id),
'course': str(self.course.id),
'location': [
self.chapter.display_name,
self.sequential2.display_name,
@@ -1194,7 +1192,7 @@ class GroupConfigurationSearchMongo(CourseTestCase, MixedWithOptionsTestCase):
return {
'start_date': datetime(2015, 4, 1, 0, 0, tzinfo=UTC),
'content': {'display_name': vertical.display_name},
'course': six.text_type(self.course.id),
'course': str(self.course.id),
'location': [
self.chapter.display_name,
self.sequential2.display_name,
@@ -1202,7 +1200,7 @@ class GroupConfigurationSearchMongo(CourseTestCase, MixedWithOptionsTestCase):
],
'content_type': 'Sequence',
'content_groups': content_groups,
'id': six.text_type(vertical.location),
'id': str(vertical.location),
'course_name': self.course.display_name,
'org': self.course.org
}
@@ -1213,9 +1211,9 @@ class GroupConfigurationSearchMongo(CourseTestCase, MixedWithOptionsTestCase):
"""
return {
'course_name': self.course.display_name,
'id': six.text_type(html_unit.location),
'id': str(html_unit.location),
'content': {'html_content': '', 'display_name': html_unit.display_name},
'course': six.text_type(self.course.id),
'course': str(self.course.id),
'location': [
self.chapter.display_name,
self.sequential.display_name,
@@ -1247,7 +1245,7 @@ class GroupConfigurationSearchMongo(CourseTestCase, MixedWithOptionsTestCase):
# Only published modules should be in the index
added_to_index = self.reindex_course(self.store)
self.assertEqual(added_to_index, 16)
response = self.searcher.search(field_dictionary={"course": six.text_type(self.course.id)})
response = self.searcher.search(field_dictionary={"course": str(self.course.id)})
self.assertEqual(response["total"], 16)
group_access_content = {'group_access': {666: [1]}}
@@ -1265,44 +1263,44 @@ class GroupConfigurationSearchMongo(CourseTestCase, MixedWithOptionsTestCase):
self.assertTrue(mock_index.called)
indexed_content = self._get_index_values_from_call_args(mock_index)
self.assertIn(self._html_group_result(self.html_unit1, [1]), indexed_content)
self.assertIn(self._html_experiment_group_result(self.html_unit4, [six.text_type(2)]), indexed_content)
self.assertIn(self._html_experiment_group_result(self.html_unit5, [six.text_type(3)]), indexed_content)
self.assertIn(self._html_experiment_group_result(self.html_unit6, [six.text_type(4)]), indexed_content)
self.assertNotIn(self._html_experiment_group_result(self.html_unit6, [six.text_type(5)]), indexed_content)
self.assertIn(self._html_experiment_group_result(self.html_unit4, [str(2)]), indexed_content)
self.assertIn(self._html_experiment_group_result(self.html_unit5, [str(3)]), indexed_content)
self.assertIn(self._html_experiment_group_result(self.html_unit6, [str(4)]), indexed_content)
self.assertNotIn(self._html_experiment_group_result(self.html_unit6, [str(5)]), indexed_content)
self.assertIn(
self._vertical_experiment_group_result(self.condition_0_vertical, [six.text_type(2)]),
self._vertical_experiment_group_result(self.condition_0_vertical, [str(2)]),
indexed_content
)
self.assertNotIn(
self._vertical_experiment_group_result(self.condition_1_vertical, [six.text_type(2)]),
self._vertical_experiment_group_result(self.condition_1_vertical, [str(2)]),
indexed_content
)
self.assertNotIn(
self._vertical_experiment_group_result(self.condition_2_vertical, [six.text_type(2)]),
self._vertical_experiment_group_result(self.condition_2_vertical, [str(2)]),
indexed_content
)
self.assertNotIn(
self._vertical_experiment_group_result(self.condition_0_vertical, [six.text_type(3)]),
self._vertical_experiment_group_result(self.condition_0_vertical, [str(3)]),
indexed_content
)
self.assertIn(
self._vertical_experiment_group_result(self.condition_1_vertical, [six.text_type(3)]),
self._vertical_experiment_group_result(self.condition_1_vertical, [str(3)]),
indexed_content
)
self.assertNotIn(
self._vertical_experiment_group_result(self.condition_2_vertical, [six.text_type(3)]),
self._vertical_experiment_group_result(self.condition_2_vertical, [str(3)]),
indexed_content
)
self.assertNotIn(
self._vertical_experiment_group_result(self.condition_0_vertical, [six.text_type(4)]),
self._vertical_experiment_group_result(self.condition_0_vertical, [str(4)]),
indexed_content
)
self.assertNotIn(
self._vertical_experiment_group_result(self.condition_1_vertical, [six.text_type(4)]),
self._vertical_experiment_group_result(self.condition_1_vertical, [str(4)]),
indexed_content
)
self.assertIn(
self._vertical_experiment_group_result(self.condition_2_vertical, [six.text_type(4)]),
self._vertical_experiment_group_result(self.condition_2_vertical, [str(4)]),
indexed_content
)
mock_index.reset_mock()

16
cms/djangoapps/contentstore/tests/test_export_git.py
View File

@@ -32,7 +32,7 @@ class TestExportGit(CourseTestCase):
"""
Setup test course, user, and url.
"""
super(TestExportGit, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.course_module = modulestore().get_course(self.course.id)
self.test_url = reverse_course_url('export_git', self.course.id)
@@ -46,7 +46,7 @@ class TestExportGit(CourseTestCase):
os.mkdir(repo_dir)
self.addCleanup(shutil.rmtree, repo_dir)
bare_repo_dir = '{0}/{1}.git'.format(
bare_repo_dir = '{}/{}.git'.format(
os.path.abspath(git_export_utils.GIT_REPO_EXPORT_DIR),
repo_name
)
@@ -55,7 +55,7 @@ class TestExportGit(CourseTestCase):
subprocess.check_output(['git', '--bare', 'init', ], cwd=bare_repo_dir)
self.populate_course()
self.course_module.giturl = 'file://{}'.format(bare_repo_dir)
self.course_module.giturl = f'file://{bare_repo_dir}'
modulestore().update_item(self.course_module, self.user.id)
def test_giturl_missing(self):
@@ -70,7 +70,7 @@ class TestExportGit(CourseTestCase):
'course settings before you can export to git.'),
)
response = self.client.get('{}?action=push'.format(self.test_url))
response = self.client.get(f'{self.test_url}?action=push')
self.assertContains(
response,
('giturl must be defined in your '
@@ -84,7 +84,7 @@ class TestExportGit(CourseTestCase):
self.course_module.giturl = 'foobar'
modulestore().update_item(self.course_module, self.user.id)
response = self.client.get('{}?action=push'.format(self.test_url))
response = self.client.get(f'{self.test_url}?action=push')
self.assertContains(response, 'Export Failed:')
def test_exception_translation(self):
@@ -94,7 +94,7 @@ class TestExportGit(CourseTestCase):
self.course_module.giturl = 'foobar'
modulestore().update_item(self.course_module, self.user.id)
response = self.client.get('{}?action=push'.format(self.test_url))
response = self.client.get(f'{self.test_url}?action=push')
self.assertNotContains(response, 'django.utils.functional.__proxy__')
def test_course_export_success(self):
@@ -103,7 +103,7 @@ class TestExportGit(CourseTestCase):
"""
self.make_bare_repo_with_course('test_repo')
response = self.client.get('{}?action=push'.format(self.test_url))
response = self.client.get(f'{self.test_url}?action=push')
self.assertContains(response, 'Export Succeeded')
def test_repo_with_dots(self):
@@ -111,7 +111,7 @@ class TestExportGit(CourseTestCase):
Regression test for a bad directory pathing of repo's that have dots.
"""
self.make_bare_repo_with_course('test.repo')
response = self.client.get('{}?action=push'.format(self.test_url))
response = self.client.get(f'{self.test_url}?action=push')
self.assertContains(response, 'Export Succeeded')
def test_dirty_repo(self):

5
cms/djangoapps/contentstore/tests/test_gating.py
View File

@@ -3,8 +3,9 @@ Unit tests for the gating feature in Studio
"""
from unittest.mock import patch
from milestones.tests.utils import MilestonesTestCaseMixin
from mock import patch
from cms.djangoapps.contentstore.signals.handlers import handle_item_deleted
from openedx.core.lib.gating import api as gating_api
@@ -22,7 +23,7 @@ class TestHandleItemDeleted(ModuleStoreTestCase, MilestonesTestCaseMixin):
"""
Initial data setup
"""
super(TestHandleItemDeleted, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.course = CourseFactory.create()
self.course.enable_subsection_gating = True

20
cms/djangoapps/contentstore/tests/test_i18n.py
View File

@@ -1,13 +1,11 @@
# -*- coding: utf-8 -*-
"""
Tests for validate Internationalization and Module i18n service.
"""
import gettext
from unittest import skip
from unittest import mock, skip
import mock
from django.contrib.auth.models import User # lint-amnesty, pylint: disable=imported-auth-user
from django.utils import translation
from django.utils.translation import get_language
@@ -62,7 +60,7 @@ class TestModuleI18nService(ModuleStoreTestCase):
def setUp(self):
""" Setting up tests """
super(TestModuleI18nService, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.test_language = 'dummy language'
self.request = mock.Mock()
self.course = CourseFactory.create()
@@ -89,7 +87,7 @@ class TestModuleI18nService(ModuleStoreTestCase):
Test django translation service works fine.
"""
class wrap_ugettext_with_xyz(object): # pylint: disable=invalid-name
class wrap_ugettext_with_xyz: # pylint: disable=invalid-name
"""
A context manager function that just adds 'XYZ ' to the front
of all strings of the module ugettext function.
@@ -187,7 +185,7 @@ class InternationalizationTest(ModuleStoreTestCase):
will be cleared out before each test case execution and deleted
afterwards.
"""
super(InternationalizationTest, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.uname = 'testuser'
self.email = 'test+courses@edx.org'
@@ -216,7 +214,7 @@ class InternationalizationTest(ModuleStoreTestCase):
resp = self.client.get_html('/home/')
self.assertContains(resp,
u'<h1 class="page-header">𝓢𝓽𝓾𝓭𝓲𝓸 Home</h1>',
'<h1 class="page-header">𝓢𝓽𝓾𝓭𝓲𝓸 Home</h1>',
status_code=200,
html=True)
@@ -232,7 +230,7 @@ class InternationalizationTest(ModuleStoreTestCase):
)
self.assertContains(resp,
u'<h1 class="page-header">𝓢𝓽𝓾𝓭𝓲𝓸 Home</h1>',
'<h1 class="page-header">𝓢𝓽𝓾𝓭𝓲𝓸 Home</h1>',
status_code=200,
html=True)
@@ -257,9 +255,9 @@ class InternationalizationTest(ModuleStoreTestCase):
)
TEST_STRING = (
u'<h1 class="title-1">'
u'My \xc7\xf6\xfcrs\xe9s L#'
u'</h1>'
'<h1 class="title-1">'
'My \xc7\xf6\xfcrs\xe9s L#'
'</h1>'
)
self.assertContains(resp,

18
cms/djangoapps/contentstore/tests/test_import.py
View File

@@ -1,4 +1,3 @@
# -*- coding: utf-8 -*-
# pylint: disable=protected-access
"""
Tests for import_course_from_xml using the mongo modulestore.
@@ -6,14 +5,13 @@ Tests for import_course_from_xml using the mongo modulestore.
import copy
from unittest.mock import patch
from uuid import uuid4
import ddt
import six
from django.conf import settings
from django.test.client import Client
from django.test.utils import override_settings
from mock import patch
from xmodule.contentstore.django import contentstore
from xmodule.exceptions import NotFoundError
@@ -37,7 +35,7 @@ class ContentStoreImportTest(ModuleStoreTestCase):
NOTE: refactor using CourseFactory so they do not.
"""
def setUp(self):
super(ContentStoreImportTest, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.client = Client()
self.client.login(username=self.user.username, password=self.user_password)
@@ -48,7 +46,7 @@ class ContentStoreImportTest(ModuleStoreTestCase):
def tearDown(self):
self.task_patcher.stop()
super(ContentStoreImportTest, self).tearDown() # lint-amnesty, pylint: disable=super-with-arguments
super().tearDown()
def load_test_import_course(self, target_id=None, create_if_not_present=True, module_store=None):
'''
@@ -97,7 +95,7 @@ class ContentStoreImportTest(ModuleStoreTestCase):
# Test with the split modulestore because store.has_course fails in old mongo with unicode characters.
with modulestore().default_store(ModuleStoreEnum.Type.split):
module_store = modulestore()
course_id = module_store.make_course_key(u'Юникода', u'unicode_course', u'échantillon')
course_id = module_store.make_course_key('Юникода', 'unicode_course', 'échantillon')
import_course_from_xml(
module_store,
self.user.id,
@@ -111,7 +109,7 @@ class ContentStoreImportTest(ModuleStoreTestCase):
self.assertIsNotNone(course)
# test that course 'display_name' same as imported course 'display_name'
self.assertEqual(course.display_name, u"Φυσικά το όνομα Unicode")
self.assertEqual(course.display_name, "Φυσικά το όνομα Unicode")
def test_static_import(self):
'''
@@ -135,7 +133,7 @@ class ContentStoreImportTest(ModuleStoreTestCase):
self.assertIsNotNone(content)
# make sure course.static_asset_path is correct
print(u"static_asset_path = {0}".format(course.static_asset_path))
print(f"static_asset_path = {course.static_asset_path}")
self.assertEqual(course.static_asset_path, 'test_import_course')
def test_asset_import_nostatic(self):
@@ -174,7 +172,7 @@ class ContentStoreImportTest(ModuleStoreTestCase):
def test_tab_name_imports_correctly(self):
_module_store, _content_store, course = self.load_test_import_course()
print(u"course tabs = {0}".format(course.tabs))
print(f"course tabs = {course.tabs}")
self.assertEqual(course.tabs[2]['name'], 'Syllabus')
def test_import_performance_mongo(self):
@@ -269,7 +267,7 @@ class ContentStoreImportTest(ModuleStoreTestCase):
self.assertIsNotNone(split_test_module)
remapped_verticals = {
key: target_id.make_usage_key('vertical', value) for key, value in six.iteritems(groups_to_verticals)
key: target_id.make_usage_key('vertical', value) for key, value in groups_to_verticals.items()
}
self.assertEqual(remapped_verticals, split_test_module.group_id_to_child)

47
cms/djangoapps/contentstore/tests/test_libraries.py
View File

@@ -3,12 +3,11 @@ Content library unit tests that require the CMS runtime.
"""
from unittest.mock import Mock, patch
import ddt
import six
from django.test.utils import override_settings
from mock import Mock, patch
from opaque_keys.edx.locator import CourseKey, LibraryLocator
from six.moves import range
from cms.djangoapps.contentstore.tests.utils import AjaxEnabledTestClient, parse_json
from cms.djangoapps.contentstore.utils import reverse_library_url, reverse_url, reverse_usage_url
@@ -41,7 +40,7 @@ class LibraryTestCase(ModuleStoreTestCase):
"""
def setUp(self):
super(LibraryTestCase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.user = UserFactory(password=self.user_password, is_staff=True)
self.client = AjaxEnabledTestClient()
@@ -85,7 +84,7 @@ class LibraryTestCase(ModuleStoreTestCase):
parent_location=course.location,
user_id=self.user.id,
publish_item=publish_item,
source_library_id=six.text_type(library_key),
source_library_id=str(library_key),
**(other_settings or {})
)
@@ -189,7 +188,7 @@ class TestLibraries(LibraryTestCase):
# Create many blocks in the library and add them to a course:
for num in range(8):
ItemFactory.create(
data=u"This is #{}".format(num + 1),
data="This is #{}".format(num + 1),
category="html", parent_location=self.library.location, user_id=self.user.id, publish_item=False
)
@@ -488,11 +487,11 @@ class TestLibraries(LibraryTestCase):
self._create_library(library="l4", display_name="Library-Title-4", org='org-test2')
self.assertEqual(len(self.client.get_json(LIBRARY_REST_URL).json()), 5) # 1 more from self.setUp()
self.assertEqual(len(self.client.get_json('{}?org=org-test1'.format(LIBRARY_REST_URL)).json()), 2)
self.assertEqual(len(self.client.get_json('{}?text_search=test-lib'.format(LIBRARY_REST_URL)).json()), 2)
self.assertEqual(len(self.client.get_json('{}?text_search=library-title'.format(LIBRARY_REST_URL)).json()), 3)
self.assertEqual(len(self.client.get_json('{}?text_search=library-'.format(LIBRARY_REST_URL)).json()), 3)
self.assertEqual(len(self.client.get_json('{}?text_search=org-test'.format(LIBRARY_REST_URL)).json()), 3)
self.assertEqual(len(self.client.get_json(f'{LIBRARY_REST_URL}?org=org-test1').json()), 2)
self.assertEqual(len(self.client.get_json(f'{LIBRARY_REST_URL}?text_search=test-lib').json()), 2)
self.assertEqual(len(self.client.get_json(f'{LIBRARY_REST_URL}?text_search=library-title').json()), 3)
self.assertEqual(len(self.client.get_json(f'{LIBRARY_REST_URL}?text_search=library-').json()), 3)
self.assertEqual(len(self.client.get_json(f'{LIBRARY_REST_URL}?text_search=org-test').json()), 3)
@ddt.ddt
@@ -504,7 +503,7 @@ class TestLibraryAccess(LibraryTestCase):
def setUp(self):
""" Create a library, staff user, and non-staff user """
super(TestLibraryAccess, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.non_staff_user_password = 'foo'
self.non_staff_user = UserFactory(password=self.non_staff_user_password, is_staff=False)
@@ -531,11 +530,11 @@ class TestLibraryAccess(LibraryTestCase):
`library` can be a LibraryLocator or the library's root XBlock
"""
if isinstance(library, (six.string_types, LibraryLocator)):
if isinstance(library, (str, LibraryLocator)):
lib_key = library
else:
lib_key = library.location.library_key
response = self.client.get(reverse_library_url('library_handler', six.text_type(lib_key)))
response = self.client.get(reverse_library_url('library_handler', str(lib_key)))
self.assertIn(response.status_code, (200, 302, 403))
return response.status_code == 200
@@ -544,7 +543,7 @@ class TestLibraryAccess(LibraryTestCase):
Log out when done each test
"""
self.client.logout()
super(TestLibraryAccess, self).tearDown() # lint-amnesty, pylint: disable=super-with-arguments
super().tearDown()
def test_creation(self):
"""
@@ -599,7 +598,7 @@ class TestLibraryAccess(LibraryTestCase):
# Now non_staff_user should be able to access library2_key only:
lib_list = self._list_libraries()
self.assertEqual(len(lib_list), 1)
self.assertEqual(lib_list[0]["library_key"], six.text_type(library2_key))
self.assertEqual(lib_list[0]["library_key"], str(library2_key))
self.assertTrue(self._can_access_library(library2_key))
self.assertFalse(self._can_access_library(self.library))
@@ -626,7 +625,7 @@ class TestLibraryAccess(LibraryTestCase):
# Now non_staff_user should be able to access lib_key_pacific only:
lib_list = self._list_libraries()
self.assertEqual(len(lib_list), 1)
self.assertEqual(lib_list[0]["library_key"], six.text_type(lib_key_pacific))
self.assertEqual(lib_list[0]["library_key"], str(lib_key_pacific))
self.assertTrue(self._can_access_library(lib_key_pacific))
self.assertFalse(self._can_access_library(lib_key_atlantic))
self.assertFalse(self._can_access_library(self.lib_key))
@@ -666,8 +665,8 @@ class TestLibraryAccess(LibraryTestCase):
def can_copy_block():
""" Check if studio lets us duplicate the XBlock in the library """
response = self.client.ajax_post(reverse_url('xblock_handler'), {
'parent_locator': six.text_type(self.library.location),
'duplicate_source_locator': six.text_type(block.location),
'parent_locator': str(self.library.location),
'duplicate_source_locator': str(block.location),
})
self.assertIn(response.status_code, (200, 403)) # 400 would be ambiguous
return response.status_code == 200
@@ -675,7 +674,7 @@ class TestLibraryAccess(LibraryTestCase):
def can_create_block():
""" Check if studio lets us make a new XBlock in the library """
response = self.client.ajax_post(reverse_url('xblock_handler'), {
'parent_locator': six.text_type(self.library.location), 'category': 'html',
'parent_locator': str(self.library.location), 'category': 'html',
})
self.assertIn(response.status_code, (200, 403)) # 400 would be ambiguous
return response.status_code == 200
@@ -728,8 +727,8 @@ class TestLibraryAccess(LibraryTestCase):
# Copy block to the course:
response = self.client.ajax_post(reverse_url('xblock_handler'), {
'parent_locator': six.text_type(course.location),
'duplicate_source_locator': six.text_type(block.location),
'parent_locator': str(course.location),
'duplicate_source_locator': str(block.location),
})
self.assertIn(response.status_code, (200, 403)) # 400 would be ambiguous
duplicate_action_allowed = (response.status_code == 200)
@@ -837,7 +836,7 @@ class TestOverrides(LibraryTestCase):
"""
def setUp(self):
super(TestOverrides, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.original_display_name = "A Problem Block"
self.original_weight = 1
@@ -1022,7 +1021,7 @@ class TestIncompatibleModuleStore(LibraryTestCase):
"""
def setUp(self):
super(TestIncompatibleModuleStore, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
# Create a course in an incompatible modulestore.
with modulestore().default_store(ModuleStoreEnum.Type.mongo):
self.course = CourseFactory.create()

19
cms/djangoapps/contentstore/tests/test_orphan.py
View File

@@ -6,7 +6,6 @@ Test finding orphans via the view and django config
import json
import ddt
import six
from opaque_keys.edx.locator import BlockUsageLocator
from cms.djangoapps.contentstore.tests.utils import CourseTestCase
@@ -95,13 +94,13 @@ class TestOrphan(TestOrphanBase):
HTTP_ACCEPT='application/json'
).content.decode('utf-8')
)
self.assertEqual(len(orphans), 3, u"Wrong # {}".format(orphans))
self.assertEqual(len(orphans), 3, f"Wrong # {orphans}")
location = course.location.replace(category='chapter', name='OrphanChapter')
self.assertIn(six.text_type(location), orphans)
self.assertIn(str(location), orphans)
location = course.location.replace(category='vertical', name='OrphanVert')
self.assertIn(six.text_type(location), orphans)
self.assertIn(str(location), orphans)
location = course.location.replace(category='html', name='OrphanHtml')
self.assertIn(six.text_type(location), orphans)
self.assertIn(str(location), orphans)
@ddt.data(
(ModuleStoreEnum.Type.split, 9, 5),
@@ -121,7 +120,7 @@ class TestOrphan(TestOrphanBase):
orphans = json.loads(
self.client.get(orphan_url, HTTP_ACCEPT='application/json').content.decode('utf-8')
)
self.assertEqual(len(orphans), 0, u"Orphans not deleted {}".format(orphans))
self.assertEqual(len(orphans), 0, f"Orphans not deleted {orphans}")
# make sure that any children with one orphan parent and one non-orphan
# parent are not deleted
@@ -174,8 +173,8 @@ class TestOrphan(TestOrphanBase):
# HTML component has `vertical1` as its parent.
html_parent = self.store.get_parent_location(multi_parent_html.location)
self.assertNotEqual(six.text_type(html_parent), six.text_type(orphan_vertical.location))
self.assertEqual(six.text_type(html_parent), six.text_type(vertical1.location))
self.assertNotEqual(str(html_parent), str(orphan_vertical.location))
self.assertEqual(str(html_parent), str(vertical1.location))
# Get path of the `multi_parent_html` & verify path_to_location returns a expected path
path = path_to_location(self.store, multi_parent_html.location)
@@ -227,7 +226,7 @@ class TestOrphan(TestOrphanBase):
# Verify chapter1 is parent of vertical1.
vertical1_parent = self.store.get_parent_location(vertical1.location)
self.assertEqual(six.text_type(vertical1_parent), six.text_type(chapter1.location))
self.assertEqual(str(vertical1_parent), str(chapter1.location))
# Make `Vertical1` the parent of `HTML0`. So `HTML0` will have to parents (`Vertical0` & `Vertical1`)
vertical1.children.append(html.location)
@@ -236,7 +235,7 @@ class TestOrphan(TestOrphanBase):
# Get parent location & verify its either of the two verticals. As both parents are non-orphan,
# alphabetically least is returned
html_parent = self.store.get_parent_location(html.location)
self.assertEqual(six.text_type(html_parent), six.text_type(vertical1.location))
self.assertEqual(str(html_parent), str(vertical1.location))
# verify path_to_location returns a expected path
path = path_to_location(self.store, html.location)

6
cms/djangoapps/contentstore/tests/test_outlines.py
View File

@@ -6,12 +6,8 @@ from datetime import datetime, timezone
from opaque_keys.edx.keys import CourseKey
from openedx.core.djangoapps.content.learning_sequences.data import (
CourseOutlineData,
ExamData,
VisibilityData,
)
from openedx.core.djangoapps.content.learning_sequences.api import get_course_outline
from openedx.core.djangoapps.content.learning_sequences.data import CourseOutlineData, ExamData, VisibilityData
from xmodule.modulestore import ModuleStoreEnum
from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory

13
cms/djangoapps/contentstore/tests/test_permissions.py
View File

@@ -6,7 +6,6 @@ Test CRUD for authorization.
import copy
from django.contrib.auth.models import User # lint-amnesty, pylint: disable=imported-auth-user
from six.moves import range
from cms.djangoapps.contentstore.tests.utils import AjaxEnabledTestClient
from cms.djangoapps.contentstore.utils import reverse_course_url, reverse_url
@@ -25,7 +24,7 @@ class TestCourseAccess(ModuleStoreTestCase):
Create a pool of users w/o granting them any permissions
"""
super(TestCourseAccess, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.client = AjaxEnabledTestClient()
self.client.login(username=self.user.username, password=self.user_password)
@@ -51,8 +50,8 @@ class TestCourseAccess(ModuleStoreTestCase):
"""
users = []
for i in range(8):
username = "user{}".format(i)
email = "test+user{}@edx.org".format(i)
username = f"user{i}"
email = f"test+user{i}@edx.org"
user = User.objects.create_user(username, email, 'foo')
user.is_active = True
user.save()
@@ -94,7 +93,7 @@ class TestCourseAccess(ModuleStoreTestCase):
user = users.pop()
group.add_users(user)
user_by_role[role].append(user)
self.assertTrue(auth.has_course_author_access(user, self.course_key), "{} does not have access".format(user)) # lint-amnesty, pylint: disable=line-too-long
self.assertTrue(auth.has_course_author_access(user, self.course_key), f"{user} does not have access") # lint-amnesty, pylint: disable=line-too-long
course_team_url = reverse_course_url('course_team_handler', self.course_key)
response = self.client.get_html(course_team_url)
@@ -127,9 +126,9 @@ class TestCourseAccess(ModuleStoreTestCase):
if hasattr(user, '_roles'):
del user._roles
self.assertTrue(auth.has_course_author_access(user, copy_course_key), u"{} no copy access".format(user))
self.assertTrue(auth.has_course_author_access(user, copy_course_key), f"{user} no copy access")
if (role is OrgStaffRole) or (role is OrgInstructorRole):
auth.remove_users(self.user, role(self.course_key.org), user)
else:
auth.remove_users(self.user, role(self.course_key), user)
self.assertFalse(auth.has_course_author_access(user, self.course_key), u"{} remove didn't work".format(user)) # lint-amnesty, pylint: disable=line-too-long
self.assertFalse(auth.has_course_author_access(user, self.course_key), f"{user} remove didn't work") # lint-amnesty, pylint: disable=line-too-long

25
cms/djangoapps/contentstore/tests/test_proctoring.py
View File

@@ -4,12 +4,11 @@ Tests for the edx_proctoring integration into Studio
from datetime import datetime, timedelta
from unittest.mock import patch
import ddt
import six
from django.conf import settings
from edx_proctoring.api import get_all_exams_for_course, get_review_policy_by_exam_id
from mock import patch
from pytz import UTC
from cms.djangoapps.contentstore.signals.handlers import listen_for_course_publish
@@ -28,7 +27,7 @@ class TestProctoredExams(ModuleStoreTestCase):
"""
Initial data setup
"""
super(TestProctoredExams, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.course = CourseFactory.create(
org='edX',
@@ -43,7 +42,7 @@ class TestProctoredExams(ModuleStoreTestCase):
Helper method to compare the sequence with the stored exam,
which should just be a single one
"""
exams = get_all_exams_for_course(six.text_type(self.course.id))
exams = get_all_exams_for_course(str(self.course.id))
self.assertEqual(len(exams), 1)
@@ -58,8 +57,8 @@ class TestProctoredExams(ModuleStoreTestCase):
# the hide after due value only applies to timed exams
self.assertEqual(exam['hide_after_due'], sequence.hide_after_due)
self.assertEqual(exam['course_id'], six.text_type(self.course.id))
self.assertEqual(exam['content_id'], six.text_type(sequence.location))
self.assertEqual(exam['course_id'], str(self.course.id))
self.assertEqual(exam['content_id'], str(sequence.location))
self.assertEqual(exam['exam_name'], sequence.display_name)
self.assertEqual(exam['time_limit_mins'], sequence.default_time_limit_minutes)
self.assertEqual(exam['is_proctored'], sequence.is_proctored_exam)
@@ -166,7 +165,7 @@ class TestProctoredExams(ModuleStoreTestCase):
listen_for_course_publish(self, self.course.id)
exams = get_all_exams_for_course(six.text_type(self.course.id))
exams = get_all_exams_for_course(str(self.course.id))
self.assertEqual(len(exams), 1)
sequence.is_time_limited = False
@@ -197,7 +196,7 @@ class TestProctoredExams(ModuleStoreTestCase):
listen_for_course_publish(self, self.course.id)
exams = get_all_exams_for_course(six.text_type(self.course.id))
exams = get_all_exams_for_course(str(self.course.id))
self.assertEqual(len(exams), 1)
self.store.delete_item(chapter.location, self.user.id)
@@ -207,7 +206,7 @@ class TestProctoredExams(ModuleStoreTestCase):
# look through exam table, the dangling exam
# should be disabled
exams = get_all_exams_for_course(six.text_type(self.course.id))
exams = get_all_exams_for_course(str(self.course.id))
self.assertEqual(len(exams), 1)
exam = exams[0]
@@ -232,7 +231,7 @@ class TestProctoredExams(ModuleStoreTestCase):
listen_for_course_publish(self, self.course.id)
exams = get_all_exams_for_course(six.text_type(self.course.id))
exams = get_all_exams_for_course(str(self.course.id))
self.assertEqual(len(exams), 0)
@ddt.data(
@@ -271,7 +270,7 @@ class TestProctoredExams(ModuleStoreTestCase):
# there shouldn't be any exams because we haven't enabled that
# advanced setting flag
exams = get_all_exams_for_course(six.text_type(self.course.id))
exams = get_all_exams_for_course(str(self.course.id))
self.assertEqual(len(exams), expected_count)
def test_self_paced_no_due_dates(self):
@@ -299,7 +298,7 @@ class TestProctoredExams(ModuleStoreTestCase):
is_onboarding_exam=False,
)
listen_for_course_publish(self, self.course.id)
exams = get_all_exams_for_course(six.text_type(self.course.id))
exams = get_all_exams_for_course(str(self.course.id))
# self-paced courses should ignore due dates
assert exams[0]['due_date'] is None
@@ -308,5 +307,5 @@ class TestProctoredExams(ModuleStoreTestCase):
self.course.self_paced = False
self.course = self.update_course(self.course, 1)
listen_for_course_publish(self, self.course.id)
exams = get_all_exams_for_course(six.text_type(self.course.id))
exams = get_all_exams_for_course(str(self.course.id))
assert exams[0]['due_date'] is not None

5
cms/djangoapps/contentstore/tests/test_request_event.py
View File

@@ -3,7 +3,6 @@
from django.test import TestCase
from django.urls import reverse
from six import unichr
from cms.djangoapps.contentstore.views.helpers import event as cms_user_track
@@ -20,7 +19,7 @@ class CMSLogTest(TestCase):
"""
requests = [
{"event": "my_event", "event_type": "my_event_type", "page": "my_page"},
{"event": "{'json': 'object'}", "event_type": unichr(512), "page": "my_page"}
{"event": "{'json': 'object'}", "event_type": chr(512), "page": "my_page"}
]
for request_params in requests:
response = self.client.post(reverse(cms_user_track), request_params)
@@ -33,7 +32,7 @@ class CMSLogTest(TestCase):
"""
requests = [
{"event": "my_event", "event_type": "my_event_type", "page": "my_page"},
{"event": "{'json': 'object'}", "event_type": unichr(512), "page": "my_page"}
{"event": "{'json': 'object'}", "event_type": chr(512), "page": "my_page"}
]
for request_params in requests:
response = self.client.get(reverse(cms_user_track), request_params)

10
cms/djangoapps/contentstore/tests/test_signals.py
View File

@@ -1,9 +1,9 @@
"""Tests for verifying availability of resources for locking"""
from unittest.mock import Mock, patch
import ddt
import six
from mock import Mock, patch
from cms.djangoapps.contentstore.signals.handlers import GRADING_POLICY_COUNTDOWN_SECONDS, handle_grading_policy_changed
from common.djangoapps.student.models import CourseEnrollment
@@ -17,7 +17,7 @@ class LockedTest(ModuleStoreTestCase):
"""Test class to verify locking of mocked resources"""
def setUp(self):
super(LockedTest, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.course = CourseFactory.create(
org='edx',
name='course',
@@ -33,9 +33,9 @@ class LockedTest(ModuleStoreTestCase):
add_mock.return_value = lock_available
sender = Mock()
handle_grading_policy_changed(sender, course_key=six.text_type(self.course.id))
handle_grading_policy_changed(sender, course_key=str(self.course.id))
cache_key = 'handle_grading_policy_changed-{}'.format(six.text_type(self.course.id))
cache_key = 'handle_grading_policy_changed-{}'.format(str(self.course.id))
self.assertEqual(lock_available, compute_grades_async_mock.called)
if lock_available:
add_mock.assert_called_once_with(cache_key, "true", GRADING_POLICY_COUNTDOWN_SECONDS)

22
cms/djangoapps/contentstore/tests/test_tasks.py
View File

@@ -5,9 +5,9 @@ Unit tests for course import and export Celery tasks
import copy
import json
from unittest import mock
from uuid import uuid4
import mock
from django.conf import settings
from django.contrib.auth.models import User # lint-amnesty, pylint: disable=imported-auth-user
from django.test.utils import override_settings
@@ -45,7 +45,7 @@ class ExportCourseTestCase(CourseTestCase):
Verify that a routine course export task succeeds
"""
key = str(self.course.location.course_key)
result = export_olx.delay(self.user.id, key, u'en')
result = export_olx.delay(self.user.id, key, 'en')
status = UserTaskStatus.objects.get(task_id=result.id)
self.assertEqual(status.state, UserTaskStatus.SUCCEEDED)
artifacts = UserTaskArtifact.objects.filter(status=status)
@@ -59,17 +59,17 @@ class ExportCourseTestCase(CourseTestCase):
The export task should fail gracefully if an exception is thrown
"""
key = str(self.course.location.course_key)
result = export_olx.delay(self.user.id, key, u'en')
self._assert_failed(result, json.dumps({u'raw_error_msg': u'Boom!'}))
result = export_olx.delay(self.user.id, key, 'en')
self._assert_failed(result, json.dumps({'raw_error_msg': 'Boom!'}))
def test_invalid_user_id(self):
"""
Verify that attempts to export a course as an invalid user fail
"""
user_id = User.objects.order_by(u'-id').first().pk + 100
user_id = User.objects.order_by('-id').first().pk + 100
key = str(self.course.location.course_key)
result = export_olx.delay(user_id, key, u'en')
self._assert_failed(result, u'Unknown User ID: {}'.format(user_id))
result = export_olx.delay(user_id, key, 'en')
self._assert_failed(result, f'Unknown User ID: {user_id}')
def test_non_course_author(self):
"""
@@ -77,8 +77,8 @@ class ExportCourseTestCase(CourseTestCase):
"""
_, nonstaff_user = self.create_non_staff_authed_user_client()
key = str(self.course.location.course_key)
result = export_olx.delay(nonstaff_user.id, key, u'en')
self._assert_failed(result, u'Permission denied')
result = export_olx.delay(nonstaff_user.id, key, 'en')
self._assert_failed(result, 'Permission denied')
def _assert_failed(self, task_result, error_message):
"""
@@ -89,7 +89,7 @@ class ExportCourseTestCase(CourseTestCase):
artifacts = UserTaskArtifact.objects.filter(status=status)
self.assertEqual(len(artifacts), 1)
error = artifacts[0]
self.assertEqual(error.name, u'Error')
self.assertEqual(error.name, 'Error')
self.assertEqual(error.text, error_message)
@@ -104,7 +104,7 @@ class ExportLibraryTestCase(LibraryTestCase):
Verify that a routine library export task succeeds
"""
key = str(self.lib_key)
result = export_olx.delay(self.user.id, key, u'en')
result = export_olx.delay(self.user.id, key, 'en')
status = UserTaskStatus.objects.get(task_id=result.id)
self.assertEqual(status.state, UserTaskStatus.SUCCEEDED)
artifacts = UserTaskArtifact.objects.filter(status=status)

76
cms/djangoapps/contentstore/tests/test_transcripts_utils.py
View File

@@ -1,4 +1,3 @@
# -*- coding: utf-8 -*-
""" Tests for transcripts_utils. """
@@ -7,6 +6,7 @@ import json
import tempfile
import textwrap
import unittest
from unittest.mock import Mock, patch
from uuid import uuid4
import ddt
@@ -14,8 +14,6 @@ import pytest
from django.conf import settings
from django.test.utils import override_settings
from django.utils import translation
from mock import Mock, patch
from six import text_type
from cms.djangoapps.contentstore.tests.utils import mock_requests_get
from common.djangoapps.student.tests.factories import UserFactory
@@ -33,7 +31,7 @@ TEST_DATA_CONTENTSTORE['DOC_STORE_CONFIG']['db'] = 'test_xcontent_%s' % uuid4().
class TestGenerateSubs(unittest.TestCase):
"""Tests for `generate_subs` function."""
def setUp(self):
super(TestGenerateSubs, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.source_subs = {
'start': [100, 200, 240, 390, 1000],
@@ -104,11 +102,11 @@ class TestSaveSubsToStore(SharedModuleStoreTestCase):
"""
A helper to compute a static file location from a subtitle id.
"""
return StaticContent.compute_location(cls.course.id, u'subs_{0}.srt.sjson'.format(sub_id))
return StaticContent.compute_location(cls.course.id, f'subs_{sub_id}.srt.sjson')
@classmethod
def setUpClass(cls):
super(TestSaveSubsToStore, cls).setUpClass()
super().setUpClass()
cls.course = CourseFactory.create(
org=cls.org, number=cls.number, display_name=cls.display_name)
@@ -125,8 +123,8 @@ class TestSaveSubsToStore(SharedModuleStoreTestCase):
}
# Prefix it to ensure that unicode filenames are allowed
cls.subs_id = u'uniçøde_{}'.format(uuid4())
cls.subs_copied_id = u'cøpy_{}'.format(uuid4())
cls.subs_id = f'uniçøde_{uuid4()}'
cls.subs_copied_id = f'cøpy_{uuid4()}'
cls.content_location = cls.sub_id_to_location(cls.subs_id)
cls.content_copied_location = cls.sub_id_to_location(cls.subs_copied_id)
@@ -138,7 +136,7 @@ class TestSaveSubsToStore(SharedModuleStoreTestCase):
cls.content_location_unjsonable = cls.sub_id_to_location(cls.unjsonable_subs_id)
def setUp(self):
super(TestSaveSubsToStore, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.addCleanup(self.clear_subs_content)
self.clear_subs_content()
@@ -186,7 +184,7 @@ class TestYoutubeSubsBase(SharedModuleStoreTestCase):
"""
@classmethod
def setUpClass(cls):
super(TestYoutubeSubsBase, cls).setUpClass()
super().setUpClass()
cls.course = CourseFactory.create(
org=cls.org, number=cls.number, display_name=cls.display_name) # lint-amnesty, pylint: disable=no-member
@@ -205,7 +203,7 @@ class TestDownloadYoutubeSubs(TestYoutubeSubsBase):
"""
Remove, if subtitle content exists.
"""
filename = 'subs_{0}.srt.sjson'.format(subs_id)
filename = f'subs_{subs_id}.srt.sjson'
content_location = StaticContent.compute_location(self.course.id, filename)
try:
content = contentstore().find(content_location)
@@ -281,7 +279,7 @@ class TestDownloadYoutubeSubs(TestYoutubeSubsBase):
# Check assets status after importing subtitles.
for subs_id in good_youtube_subs.values(): # lint-amnesty, pylint: disable=undefined-variable
filename = 'subs_{0}.srt.sjson'.format(subs_id)
filename = f'subs_{subs_id}.srt.sjson'
content_location = StaticContent.compute_location(
self.course.id, filename
)
@@ -381,7 +379,7 @@ class TestGenerateSubsFromSource(TestDownloadYoutubeSubs): # lint-amnesty, pyli
# Check assets status after importing subtitles.
for subs_id in youtube_subs.values():
filename = 'subs_{0}.srt.sjson'.format(subs_id)
filename = f'subs_{subs_id}.srt.sjson'
content_location = StaticContent.compute_location(
self.course.id, filename
)
@@ -408,7 +406,7 @@ class TestGenerateSubsFromSource(TestDownloadYoutubeSubs): # lint-amnesty, pyli
with self.assertRaises(transcripts_utils.TranscriptsGenerationException) as cm:
transcripts_utils.generate_subs_from_source(youtube_subs, 'BAD_FORMAT', srt_filedata, self.course)
exception_message = text_type(cm.exception)
exception_message = str(cm.exception)
self.assertEqual(exception_message, "We support only SubRip (*.srt) transcripts format.")
def test_fail_bad_subs_filedata(self):
@@ -422,7 +420,7 @@ class TestGenerateSubsFromSource(TestDownloadYoutubeSubs): # lint-amnesty, pyli
with self.assertRaises(transcripts_utils.TranscriptsGenerationException) as cm:
transcripts_utils.generate_subs_from_source(youtube_subs, 'srt', srt_filedata, self.course)
exception_message = text_type(cm.exception)
exception_message = str(cm.exception)
self.assertEqual(exception_message, "Something wrong with SubRip transcripts file during parsing.")
@@ -561,7 +559,7 @@ class TestTranscript(unittest.TestCase):
Tests for Transcript class e.g. different transcript conversions.
"""
def setUp(self):
super(TestTranscript, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.srt_transcript = textwrap.dedent("""\
0
@@ -591,7 +589,7 @@ class TestTranscript(unittest.TestCase):
}
""")
self.txt_transcript = u"Elephant's Dream\nAt the left we can see..."
self.txt_transcript = "Elephant's Dream\nAt the left we can see..."
def test_convert_srt_to_txt(self):
"""
@@ -659,10 +657,10 @@ class TestSubsFilename(unittest.TestCase):
"""
def test_unicode(self):
name = transcripts_utils.subs_filename(u"˙∆©ƒƒƒ")
self.assertEqual(name, u'subs_˙∆©ƒƒƒ.srt.sjson')
name = transcripts_utils.subs_filename(u"˙∆©ƒƒƒ", 'uk')
self.assertEqual(name, u'uk_subs_˙∆©ƒƒƒ.srt.sjson')
name = transcripts_utils.subs_filename("˙∆©ƒƒƒ")
self.assertEqual(name, 'subs_˙∆©ƒƒƒ.srt.sjson')
name = transcripts_utils.subs_filename("˙∆©ƒƒƒ", 'uk')
self.assertEqual(name, 'uk_subs_˙∆©ƒƒƒ.srt.sjson')
@ddt.ddt
@@ -710,7 +708,7 @@ class TestGetTranscript(SharedModuleStoreTestCase):
"""Tests for `get_transcript` function."""
def setUp(self):
super(TestGetTranscript, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.course = CourseFactory.create()
@@ -731,8 +729,8 @@ class TestGetTranscript(SharedModuleStoreTestCase):
self.subs_srt = transcripts_utils.Transcript.convert(json.dumps(self.subs_sjson), 'sjson', 'srt')
self.subs = {
u'en': self.subs_srt,
u'ur': transcripts_utils.Transcript.convert(json.dumps(self.subs_sjson), 'sjson', 'srt'),
'en': self.subs_srt,
'ur': transcripts_utils.Transcript.convert(json.dumps(self.subs_sjson), 'sjson', 'srt'),
}
self.srt_mime_type = transcripts_utils.Transcript.mime_types[transcripts_utils.Transcript.SRT]
@@ -743,15 +741,15 @@ class TestGetTranscript(SharedModuleStoreTestCase):
self.video = ItemFactory.create(
category='video',
parent_location=self.vertical.location,
edx_video_id=u'1234-5678-90'
edx_video_id='1234-5678-90'
)
def create_transcript(self, subs_id, language=u'en', filename='video.srt', youtube_id_1_0='', html5_sources=None):
def create_transcript(self, subs_id, language='en', filename='video.srt', youtube_id_1_0='', html5_sources=None):
"""
create transcript.
"""
transcripts = {}
if language != u'en':
if language != 'en':
transcripts = {language: filename}
html5_sources = html5_sources or []
@@ -761,7 +759,7 @@ class TestGetTranscript(SharedModuleStoreTestCase):
sub=subs_id,
youtube_id_1_0=youtube_id_1_0,
transcripts=transcripts,
edx_video_id=u'1234-5678-90',
edx_video_id='1234-5678-90',
html5_sources=html5_sources
)
@@ -803,9 +801,9 @@ class TestGetTranscript(SharedModuleStoreTestCase):
@ddt.data(
# en lang does not exist so NotFoundError will be raised
(u'en',),
('en',),
# ur lang does not exist so KeyError and then NotFoundError will be raised
(u'ur',),
('ur',),
)
@ddt.unpack
def test_get_transcript_not_found(self, lang):
@@ -821,7 +819,7 @@ class TestGetTranscript(SharedModuleStoreTestCase):
@ddt.data(
# video.sub transcript
{
'language': u'en',
'language': 'en',
'subs_id': 'video_101',
'youtube_id_1_0': '',
'html5_sources': [],
@@ -829,7 +827,7 @@ class TestGetTranscript(SharedModuleStoreTestCase):
},
# if video.sub is present, rest will be skipped.
{
'language': u'en',
'language': 'en',
'subs_id': 'video_101',
'youtube_id_1_0': 'test_yt_id',
'html5_sources': ['www.abc.com/foo.mp4'],
@@ -837,7 +835,7 @@ class TestGetTranscript(SharedModuleStoreTestCase):
},
# video.youtube_id_1_0 transcript
{
'language': u'en',
'language': 'en',
'subs_id': '',
'youtube_id_1_0': 'test_yt_id',
'html5_sources': [],
@@ -845,7 +843,7 @@ class TestGetTranscript(SharedModuleStoreTestCase):
},
# video.html5_sources transcript
{
'language': u'en',
'language': 'en',
'subs_id': '',
'youtube_id_1_0': '',
'html5_sources': ['www.abc.com/foo.mp4'],
@@ -853,7 +851,7 @@ class TestGetTranscript(SharedModuleStoreTestCase):
},
# non-english transcript
{
'language': u'ur',
'language': 'ur',
'subs_id': '',
'youtube_id_1_0': '',
'html5_sources': [],
@@ -888,7 +886,7 @@ class TestGetTranscript(SharedModuleStoreTestCase):
"""
Verify that `get_transcript` function returns correct data for non-english when transcript is in content store.
"""
language = u'ur'
language = 'ur'
self.create_transcript(self.subs_id, language)
content, filename, mimetype = transcripts_utils.get_transcript(
self.video,
@@ -928,7 +926,7 @@ class TestGetTranscript(SharedModuleStoreTestCase):
output_format='mpeg'
)
exception_message = text_type(invalid_format_exception.exception)
exception_message = str(invalid_format_exception.exception)
self.assertEqual(exception_message, 'Invalid transcript format `mpeg`')
def test_get_transcript_no_content(self):
@@ -944,7 +942,7 @@ class TestGetTranscript(SharedModuleStoreTestCase):
'ur'
)
exception_message = text_type(no_content_exception.exception)
exception_message = str(no_content_exception.exception)
self.assertEqual(exception_message, 'No transcript content')
def test_get_transcript_no_en_transcript(self):
@@ -959,7 +957,7 @@ class TestGetTranscript(SharedModuleStoreTestCase):
'en'
)
exception_message = text_type(no_en_transcript_exception.exception)
exception_message = str(no_en_transcript_exception.exception)
self.assertEqual(exception_message, 'No transcript for `en` language')
@ddt.data(

6
cms/djangoapps/contentstore/tests/test_users_default_role.py
View File

@@ -6,8 +6,8 @@ after deleting it creates same course again
from cms.djangoapps.contentstore.tests.utils import AjaxEnabledTestClient
from cms.djangoapps.contentstore.utils import delete_course, reverse_url
from lms.djangoapps.courseware.tests.factories import UserFactory
from common.djangoapps.student.models import CourseEnrollment
from lms.djangoapps.courseware.tests.factories import UserFactory
from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
@@ -19,7 +19,7 @@ class TestUsersDefaultRole(ModuleStoreTestCase):
"""
Add a user and a course
"""
super(TestUsersDefaultRole, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
# create and log in a staff user.
self.user = UserFactory(is_staff=True)
self.client = AjaxEnabledTestClient()
@@ -49,7 +49,7 @@ class TestUsersDefaultRole(ModuleStoreTestCase):
Reverse the setup
"""
self.client.logout()
super(TestUsersDefaultRole, self).tearDown() # lint-amnesty, pylint: disable=super-with-arguments
super().tearDown()
def test_user_forum_default_role_on_course_deletion(self):
"""

27
cms/djangoapps/contentstore/tests/test_utils.py
View File

@@ -4,7 +4,6 @@
import collections
from datetime import datetime, timedelta
import six
from django.test import TestCase
from opaque_keys.edx.locator import CourseLocator
from pytz import UTC
@@ -83,7 +82,7 @@ class ExtraPanelTabTestCase(TestCase):
if tabs is None:
tabs = []
course = collections.namedtuple('MockCourse', ['tabs'])
if isinstance(tabs, six.string_types):
if isinstance(tabs, str):
course.tabs = self.get_tab_type_dicts(tabs)
else:
course.tabs = tabs
@@ -95,7 +94,7 @@ class XBlockVisibilityTestCase(SharedModuleStoreTestCase):
@classmethod
def setUpClass(cls):
super(XBlockVisibilityTestCase, cls).setUpClass()
super().setUpClass()
cls.dummy_user = ModuleStoreEnum.UserID.test
cls.past = datetime(1970, 1, 1, tzinfo=UTC)
@@ -168,7 +167,7 @@ class ReleaseDateSourceTest(CourseTestCase):
"""Tests for finding the source of an xblock's release date."""
def setUp(self):
super(ReleaseDateSourceTest, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.chapter = ItemFactory.create(category='chapter', parent_location=self.course.location)
self.sequential = ItemFactory.create(category='sequential', parent_location=self.chapter.location)
@@ -222,7 +221,7 @@ class StaffLockTest(CourseTestCase):
"""Base class for testing staff lock functions."""
def setUp(self):
super(StaffLockTest, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.chapter = ItemFactory.create(category='chapter', parent_location=self.course.location)
self.sequential = ItemFactory.create(category='sequential', parent_location=self.chapter.location)
@@ -332,7 +331,7 @@ class GroupVisibilityTest(CourseTestCase):
"""
def setUp(self):
super(GroupVisibilityTest, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
chapter = ItemFactory.create(category='chapter', parent_location=self.course.location)
sequential = ItemFactory.create(category='sequential', parent_location=chapter.location)
@@ -432,7 +431,7 @@ class GetUserPartitionInfoTest(ModuleStoreTestCase):
def setUp(self):
"""Create a dummy course. """
super(GetUserPartitionInfoTest, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.course = CourseFactory()
self.block = ItemFactory.create(category="problem", parent_location=self.course.location)
@@ -465,18 +464,18 @@ class GetUserPartitionInfoTest(ModuleStoreTestCase):
expected = [
{
"id": 0,
"name": u"Cohort user partition",
"scheme": u"cohort",
"name": "Cohort user partition",
"scheme": "cohort",
"groups": [
{
"id": 0,
"name": u"Group A",
"name": "Group A",
"selected": False,
"deleted": False,
},
{
"id": 1,
"name": u"Group B",
"name": "Group B",
"selected": False,
"deleted": False,
},
@@ -484,12 +483,12 @@ class GetUserPartitionInfoTest(ModuleStoreTestCase):
},
{
"id": 1,
"name": u"Random user partition",
"scheme": u"random",
"name": "Random user partition",
"scheme": "random",
"groups": [
{
"id": 0,
"name": u"Group C",
"name": "Group C",
"selected": False,
"deleted": False,
},

28
cms/djangoapps/contentstore/tests/test_video_utils.py
View File

@@ -1,4 +1,3 @@
#-*- coding: utf-8 -*-
"""
Unit tests for video utils.
"""
@@ -6,16 +5,15 @@ Unit tests for video utils.
from datetime import datetime
from unittest import TestCase
from unittest.mock import patch
import ddt
import pytz
import requests
import six
from django.conf import settings
from django.core.files.uploadedfile import UploadedFile
from django.test.utils import override_settings
from edxval.api import create_profile, create_video, get_course_video_image_url, update_video_image
from mock import patch
from cms.djangoapps.contentstore.tests.utils import CourseTestCase
from cms.djangoapps.contentstore.video_utils import (
@@ -59,8 +57,8 @@ class ScrapeVideoThumbnailsTestCase(CourseTestCase):
"""
def setUp(self):
super(ScrapeVideoThumbnailsTestCase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
course_ids = [six.text_type(self.course.id)]
super().setUp()
course_ids = [str(self.course.id)]
profiles = ['youtube']
created = datetime.now(pytz.utc)
previous_uploads = [
@@ -116,7 +114,7 @@ class ScrapeVideoThumbnailsTestCase(CourseTestCase):
# Create video images.
with make_image_file() as image_file:
update_video_image(
'test-youtube-video-2', six.text_type(self.course.id), image_file, 'image.jpg'
'test-youtube-video-2', str(self.course.id), image_file, 'image.jpg'
)
def mocked_youtube_thumbnail_response(
@@ -232,7 +230,7 @@ class ScrapeVideoThumbnailsTestCase(CourseTestCase):
"""
Test that youtube thumbnails are correctly scrapped.
"""
course_id = six.text_type(self.course.id)
course_id = str(self.course.id)
video1_edx_video_id = 'test-youtube-video-1'
video2_edx_video_id = 'test-youtube-video-2'
@@ -286,7 +284,7 @@ class ScrapeVideoThumbnailsTestCase(CourseTestCase):
"""
Test that we get correct logs in case of failure as well as success.
"""
course_id = six.text_type(self.course.id)
course_id = str(self.course.id)
video1_edx_video_id = 'test-youtube-video-1'
mocked_request.side_effect = [
self.mocked_youtube_thumbnail_response(
@@ -297,13 +295,13 @@ class ScrapeVideoThumbnailsTestCase(CourseTestCase):
scrape_youtube_thumbnail(course_id, video1_edx_video_id, 'test-yt-id')
if is_success:
mock_logger.info.assert_called_with(
u'VIDEOS: Scraping youtube video thumbnail for edx_video_id [%s] in course [%s]',
'VIDEOS: Scraping youtube video thumbnail for edx_video_id [%s] in course [%s]',
video1_edx_video_id,
course_id
)
else:
mock_logger.info.assert_called_with(
u'VIDEOS: Scraping youtube video thumbnail failed for edx_video_id [%s] in course [%s] with error: %s',
'VIDEOS: Scraping youtube video thumbnail failed for edx_video_id [%s] in course [%s] with error: %s',
video1_edx_video_id,
course_id,
'This image file must be larger than 2 KB.'
@@ -313,21 +311,21 @@ class ScrapeVideoThumbnailsTestCase(CourseTestCase):
(
None,
'image/jpeg',
u'This image file must be larger than {image_min_size}.'.format(
'This image file must be larger than {image_min_size}.'.format(
image_min_size=settings.VIDEO_IMAGE_MIN_FILE_SIZE_KB
)
),
(
b'dummy-content',
None,
u'This image file type is not supported. Supported file types are {supported_file_formats}.'.format(
'This image file type is not supported. Supported file types are {supported_file_formats}.'.format(
supported_file_formats=list(settings.VIDEO_IMAGE_SUPPORTED_FILE_FORMATS.keys())
)
),
(
None,
None,
u'This image file type is not supported. Supported file types are {supported_file_formats}.'.format(
'This image file type is not supported. Supported file types are {supported_file_formats}.'.format(
supported_file_formats=list(settings.VIDEO_IMAGE_SUPPORTED_FILE_FORMATS.keys())
)
),
@@ -347,7 +345,7 @@ class ScrapeVideoThumbnailsTestCase(CourseTestCase):
Test that when no thumbnail is downloaded, video image is not updated.
"""
mock_download_youtube_thumbnail.return_value = image_content, image_content_type
course_id = six.text_type(self.course.id)
course_id = str(self.course.id)
video1_edx_video_id = 'test-youtube-video-1'
# Verify that video1 has no image attached.
@@ -358,7 +356,7 @@ class ScrapeVideoThumbnailsTestCase(CourseTestCase):
scrape_youtube_thumbnail(course_id, video1_edx_video_id, 'test-yt-id')
mock_logger.info.assert_called_with(
u'VIDEOS: Scraping youtube video thumbnail failed for edx_video_id [%s] in course [%s] with error: %s',
'VIDEOS: Scraping youtube video thumbnail failed for edx_video_id [%s] in course [%s] with error: %s',
video1_edx_video_id,
course_id,
error_message

16
cms/djangoapps/contentstore/tests/tests.py
View File

@@ -5,8 +5,8 @@ This test file will test registration, login, activation, and session activity t
import datetime
import time
from unittest import mock
import mock
from ddt import data, ddt, unpack
from django.conf import settings
from django.core.cache import cache
@@ -91,7 +91,7 @@ class AuthTestCase(ContentStoreTestCase):
ENABLED_CACHES = ['default', 'mongo_metadata_inheritance', 'loc_cache']
def setUp(self):
super(AuthTestCase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.email = 'a@b.com'
self.pw = 'xyz'
@@ -127,7 +127,7 @@ class AuthTestCase(ContentStoreTestCase):
# Not logged in. Should redirect to login.
print('Not logged in')
for page in auth_pages:
print(u"Checking '{0}'".format(page))
print(f"Checking '{page}'")
self.check_page_get(page, expected=302)
# Logged in should work.
@@ -135,7 +135,7 @@ class AuthTestCase(ContentStoreTestCase):
print('Logged in')
for page in simple_auth_pages:
print(u"Checking '{0}'".format(page))
print(f"Checking '{page}'")
self.check_page_get(page, expected=200)
@override_settings(SESSION_INACTIVITY_TIMEOUT_IN_SECONDS=1)
@@ -176,7 +176,7 @@ class AuthTestCase(ContentStoreTestCase):
assertion_method = getattr(self, assertion_method_name)
assertion_method(
response,
u'<a class="action action-signup" href="{}/register?next=http%3A%2F%2Ftestserver%2F">Sign Up</a>'.format
'<a class="action action-signup" href="{}/register?next=http%3A%2F%2Ftestserver%2F">Sign Up</a>'.format
(settings.LMS_ROOT_URL)
)
self.assertContains(
@@ -191,7 +191,7 @@ class ForumTestCase(CourseTestCase):
def setUp(self):
""" Creates the test course. """
super(ForumTestCase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.course = CourseFactory.create(org='testX', number='727', display_name='Forum Course')
def set_blackout_dates(self, blackout_dates):
@@ -242,7 +242,7 @@ class CourseKeyVerificationTestCase(CourseTestCase):
"""
Create test course.
"""
super(CourseKeyVerificationTestCase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.course = CourseFactory.create(org='edX', number='test_course_key', display_name='Test Course')
@data(('edX/test_course_key/Test_Course', 200), ('garbage:edX+test_course_key+Test_Course', 404))
@@ -251,7 +251,7 @@ class CourseKeyVerificationTestCase(CourseTestCase):
"""
Tests for the ensure_valid_course_key decorator.
"""
url = '/import/{course_key}'.format(course_key=course_key)
url = f'/import/{course_key}'
resp = self.client.get_html(url)
self.assertEqual(resp.status_code, status_code)

17
cms/djangoapps/contentstore/tests/utils.py
View File

@@ -5,12 +5,11 @@ Utilities for contentstore tests
import json
import textwrap
from unittest.mock import Mock
import six
from django.conf import settings
from django.contrib.auth.models import User # lint-amnesty, pylint: disable=imported-auth-user
from django.test.client import Client
from mock import Mock
from opaque_keys.edx.keys import AssetKey, CourseKey
from cms.djangoapps.contentstore.utils import reverse_url
@@ -51,7 +50,7 @@ class AjaxEnabledTestClient(Client):
Convenience method for client post which serializes the data into json and sets the accept type
to json
"""
if not isinstance(data, six.string_types):
if not isinstance(data, str):
data = json.dumps(data or {})
kwargs.setdefault("HTTP_X_REQUESTED_WITH", "XMLHttpRequest")
kwargs.setdefault("HTTP_ACCEPT", "application/json")
@@ -84,7 +83,7 @@ class CourseTestCase(ProceduralCourseTestMixin, ModuleStoreTestCase):
afterwards.
"""
super(CourseTestCase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
super().setUp()
self.client = AjaxEnabledTestClient()
self.client.login(username=self.user.username, password=self.user_password)
@@ -195,7 +194,7 @@ class CourseTestCase(ProceduralCourseTestMixin, ModuleStoreTestCase):
html_module = self.store.get_item(course_id.make_usage_key('html', 'nonportable'))
new_data = html_module.data = html_module.data.replace(
'/static/',
'/c4x/{0}/{1}/asset/'.format(course_id.org, course_id.course)
f'/c4x/{course_id.org}/{course_id.course}/asset/'
)
self.store.update_item(html_module, self.user.id)
@@ -285,10 +284,10 @@ class CourseTestCase(ProceduralCourseTestMixin, ModuleStoreTestCase):
course2_items = self.store.get_items(course2_id)
self.assertGreater(len(course1_items), 0) # ensure it found content instead of [] == []
if len(course1_items) != len(course2_items):
course1_block_ids = set([item.location.block_id for item in course1_items]) # lint-amnesty, pylint: disable=consider-using-set-comprehension
course2_block_ids = set([item.location.block_id for item in course2_items]) # lint-amnesty, pylint: disable=consider-using-set-comprehension
course1_block_ids = {item.location.block_id for item in course1_items}
course2_block_ids = {item.location.block_id for item in course2_items}
raise AssertionError(
u"Course1 extra blocks: {}; course2 extra blocks: {}".format(
"Course1 extra blocks: {}; course2 extra blocks: {}".format(
course1_block_ids - course2_block_ids, course2_block_ids - course1_block_ids
)
)
@@ -357,7 +356,7 @@ class CourseTestCase(ProceduralCourseTestMixin, ModuleStoreTestCase):
course1_asset_attrs = content_store.get_attrs(course1_id.make_asset_key(category, filename))
course2_asset_attrs = content_store.get_attrs(course2_id.make_asset_key(category, filename))
self.assertEqual(len(course1_asset_attrs), len(course2_asset_attrs))
for key, value in six.iteritems(course1_asset_attrs):
for key, value in course1_asset_attrs.items():
if key in ['_id', 'filename', 'uploadDate', 'content_son', 'thumbnail_location']:
pass
else: