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

Merge pull request #22643 from edx/feanil/2to3_asserts

Browse Source 
Run `2to3 -f asserts . -w` on edx-platform.
This commit is contained in:
Feanil Patel
2019-12-30 12:13:42 -05:00
committed by GitHub
parent 61e1eda20d 39d3a7ca17
commit 2df8b8226b
214 changed files with 1459 additions and 1464 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
openedx/core/djangoapps/content/block_structure/management/commands/tests/test_generate_course_blocks.py
View File

@@ -146,7 +146,7 @@ class TestGenerateCourseBlocks(ModuleStoreTestCase):
task_action = mock_tasks.get_course_in_cache_v2
task_options = task_action.apply_async.call_args[1]
if routing_key:
self.assertEquals(task_options['routing_key'], routing_key)
self.assertEqual(task_options['routing_key'], routing_key)
else:
self.assertNotIn('routing_key', task_options)

30
openedx/core/djangoapps/content/block_structure/tests/test_block_structure.py
View File

@@ -66,7 +66,7 @@ class TestBlockStructureData(TestCase, ChildrenMapTestMixin):
block_structure = BlockStructureModulestoreData(root_block_usage_key=0)
with self.assertRaisesRegexp(TransformerException, "Version attributes are not set"):
with self.assertRaisesRegex(TransformerException, "Version attributes are not set"):
block_structure._add_transformer(TestNonVersionedTransformer())
def test_transformer_data(self):
@@ -107,18 +107,18 @@ class TestBlockStructureData(TestCase, ChildrenMapTestMixin):
# verify transformer data
for t_info in transformers_info:
self.assertEquals(
self.assertEqual(
block_structure._get_transformer_data_version(t_info.transformer),
MockTransformer.WRITE_VERSION
)
for key, val in t_info.structure_wide_data:
self.assertEquals(
self.assertEqual(
block_structure.get_transformer_data(t_info.transformer, key),
val,
)
for block, block_data in six.iteritems(t_info.block_specific_data):
for key, val in block_data:
self.assertEquals(
self.assertEqual(
block_structure.get_transformer_block_field(block, t_info.transformer, key),
val,
)
@@ -156,7 +156,7 @@ class TestBlockStructureData(TestCase, ChildrenMapTestMixin):
for block in blocks:
bs_block = block_structure[block.location]
for field in fields:
self.assertEquals(
self.assertEqual(
getattr(bs_block, field, None),
block.field_map.get(field),
)
@@ -185,7 +185,7 @@ class TestBlockStructureData(TestCase, ChildrenMapTestMixin):
# verify values of collected fields
bs_block = block_structure[block.location]
for field in fields:
self.assertEquals(
self.assertEqual(
getattr(bs_block, field, None),
block.field_map.get(field),
)
@@ -195,7 +195,7 @@ class TestBlockStructureData(TestCase, ChildrenMapTestMixin):
"due",
override_due_date
)
self.assertEquals(
self.assertEqual(
block_structure.get_xblock_field(block.location, "due", None),
override_due_date
)
@@ -288,12 +288,12 @@ class TestBlockStructureData(TestCase, ChildrenMapTestMixin):
# create a new copy of the structure and verify they are equivalent
new_copy = block_structure.copy()
self.assertEquals(block_structure.root_block_usage_key, new_copy.root_block_usage_key)
self.assertEqual(block_structure.root_block_usage_key, new_copy.root_block_usage_key)
for block in block_structure:
self.assertIn(block, new_copy)
self.assertEquals(block_structure.get_parents(block), new_copy.get_parents(block))
self.assertEquals(block_structure.get_children(block), new_copy.get_children(block))
self.assertEquals(_get_value(block_structure), _get_value(new_copy))
self.assertEqual(block_structure.get_parents(block), new_copy.get_parents(block))
self.assertEqual(block_structure.get_children(block), new_copy.get_children(block))
self.assertEqual(_get_value(block_structure), _get_value(new_copy))
# verify edits to original block structure do not affect the copy
block_structure.remove_block(2, keep_descendants=True)
@@ -301,8 +301,8 @@ class TestBlockStructureData(TestCase, ChildrenMapTestMixin):
self.assert_block_structure(new_copy, [[1], [2], [3], []])
_set_value(block_structure, 'edit1')
self.assertEquals(_get_value(block_structure), 'edit1')
self.assertEquals(_get_value(new_copy), 'original_value')
self.assertEqual(_get_value(block_structure), 'edit1')
self.assertEqual(_get_value(new_copy), 'original_value')
# verify edits to copy do not affect the original
new_copy.remove_block(3, keep_descendants=True)
@@ -310,5 +310,5 @@ class TestBlockStructureData(TestCase, ChildrenMapTestMixin):
self.assert_block_structure(new_copy, [[1], [2], [], []], missing_blocks=[3])
_set_value(new_copy, 'edit2')
self.assertEquals(_get_value(block_structure), 'edit1')
self.assertEquals(_get_value(new_copy), 'edit2')
self.assertEqual(_get_value(block_structure), 'edit1')
self.assertEqual(_get_value(new_copy), 'edit2')

2
openedx/core/djangoapps/content/block_structure/tests/test_signals.py
View File

@@ -60,7 +60,7 @@ class CourseBlocksSignalTest(ModuleStoreTestCase):
self.course.display_name = test_display_name
self.store.update_item(self.course, self.user.id)
self.assertEquals(mock_bs_manager_clear.called, invalidate_cache_enabled)
self.assertEqual(mock_bs_manager_clear.called, invalidate_cache_enabled)
def test_course_delete(self):
bs_manager = get_block_structure_manager(self.course.id)

4
openedx/core/djangoapps/content/block_structure/tests/test_transformers.py
View File

@@ -51,8 +51,8 @@ class TestBlockStructureTransformers(ChildrenMapTestMixin, TestCase):
with self.assertRaises(TransformerException):
self.transformers += [self.UnregisteredTransformer()]
self.assertEquals(self.transformers._transformers['no_filter'], []) # pylint: disable=protected-access
self.assertEquals(self.transformers._transformers['supports_filter'], []) # pylint: disable=protected-access
self.assertEqual(self.transformers._transformers['no_filter'], []) # pylint: disable=protected-access
self.assertEqual(self.transformers._transformers['supports_filter'], []) # pylint: disable=protected-access
def test_collect(self):
with mock_registered_transformers(self.registered_transformers):

8
openedx/core/djangoapps/content/course_overviews/management/commands/tests/test_generate_course_overview.py
View File

@@ -77,8 +77,8 @@ class TestGenerateCourseOverview(ModuleStoreTestCase):
self.command.handle(six.text_type(self.course_key_1), all_courses=False, force_update=True)
self.command.handle(six.text_type(self.course_key_2), all_courses=False, force_update=False)
self.assertEquals(CourseOverview.get_from_id(self.course_key_1).display_name, updated_course_name)
self.assertNotEquals(CourseOverview.get_from_id(self.course_key_2).display_name, updated_course_name)
self.assertEqual(CourseOverview.get_from_id(self.course_key_1).display_name, updated_course_name)
self.assertNotEqual(CourseOverview.get_from_id(self.course_key_2).display_name, updated_course_name)
def test_invalid_key(self):
"""
@@ -107,11 +107,11 @@ class TestGenerateCourseOverview(ModuleStoreTestCase):
self.command.handle(all_courses=True, force_update=True, routing_key='my-routing-key', chunk_size=10000)
called_kwargs = mock_async_task.apply_async.call_args_list[0][1]
self.assertEquals(
self.assertEqual(
sorted([six.text_type(self.course_key_1), six.text_type(self.course_key_2)]),
sorted(called_kwargs.pop('args'))
)
self.assertEquals({
self.assertEqual({
'kwargs': {'force_update': True},
'routing_key': 'my-routing-key'
}, called_kwargs

2
openedx/core/djangoapps/content/course_overviews/tests/test_course_overviews.py
View File

@@ -488,7 +488,7 @@ class CourseOverviewTestCase(CatalogIntegrationMixin, ModuleStoreTestCase, Cache
'openedx.core.djangoapps.content.course_overviews.models.CourseOverview.get_from_id'
) as mock_get_from_id:
CourseOverview.update_select_courses(select_course_ids)
self.assertEquals(mock_get_from_id.call_count, len(select_course_ids))
self.assertEqual(mock_get_from_id.call_count, len(select_course_ids))
def test_get_all_courses(self):
course_ids = [CourseFactory.create(emit_signals=True).id for __ in range(3)]

10
openedx/core/djangoapps/contentserver/test/test_contentserver.py
View File

@@ -291,7 +291,7 @@ class ContentStoreToyCourseTest(SharedModuleStoreTestCase):
"""
resp = self.client.get(self.url_unlocked)
self.assertEqual(resp.status_code, 200)
self.assertEquals('Origin', resp['Vary'])
self.assertEqual('Origin', resp['Vary'])
@patch('openedx.core.djangoapps.contentserver.models.CourseAssetCacheTtlConfig.get_cache_ttl')
def test_cache_headers_with_ttl_unlocked(self, mock_get_cache_ttl):
@@ -304,7 +304,7 @@ class ContentStoreToyCourseTest(SharedModuleStoreTestCase):
resp = self.client.get(self.url_unlocked)
self.assertEqual(resp.status_code, 200)
self.assertIn('Expires', resp)
self.assertEquals('public, max-age=10, s-maxage=10', resp['Cache-Control'])
self.assertEqual('public, max-age=10, s-maxage=10', resp['Cache-Control'])
@patch('openedx.core.djangoapps.contentserver.models.CourseAssetCacheTtlConfig.get_cache_ttl')
def test_cache_headers_with_ttl_locked(self, mock_get_cache_ttl):
@@ -321,7 +321,7 @@ class ContentStoreToyCourseTest(SharedModuleStoreTestCase):
resp = self.client.get(self.url_locked)
self.assertEqual(resp.status_code, 200)
self.assertNotIn('Expires', resp)
self.assertEquals('private, no-cache, no-store', resp['Cache-Control'])
self.assertEqual('private, no-cache, no-store', resp['Cache-Control'])
@patch('openedx.core.djangoapps.contentserver.models.CourseAssetCacheTtlConfig.get_cache_ttl')
def test_cache_headers_without_ttl_unlocked(self, mock_get_cache_ttl):
@@ -351,7 +351,7 @@ class ContentStoreToyCourseTest(SharedModuleStoreTestCase):
resp = self.client.get(self.url_locked)
self.assertEqual(resp.status_code, 200)
self.assertNotIn('Expires', resp)
self.assertEquals('private, no-cache, no-store', resp['Cache-Control'])
self.assertEqual('private, no-cache, no-store', resp['Cache-Control'])
def test_get_expiration_value(self):
start_dt = datetime.datetime.strptime("Thu, 01 Dec 1983 20:00:00 GMT", HTTP_DATE_FORMAT)
@@ -443,6 +443,6 @@ class ParseRangeHeaderTestCase(unittest.TestCase):
)
@ddt.unpack
def test_invalid_syntax(self, header_value, exception_class, exception_message_regex):
self.assertRaisesRegexp(
self.assertRaisesRegex(
exception_class, exception_message_regex, parse_range_header, header_value, self.content_length
)

2
openedx/core/djangoapps/cors_csrf/tests/test_authentication.py
View File

@@ -32,7 +32,7 @@ class CrossDomainAuthTest(TestCase):
def test_perform_csrf_referer_check(self):
request = self._fake_request()
with self.assertRaisesRegexp(PermissionDenied, 'CSRF'):
with self.assertRaisesRegex(PermissionDenied, 'CSRF'):
self.auth.enforce_csrf(request)
@patch.dict(settings.FEATURES, {

32
openedx/core/djangoapps/course_groups/tests/test_cohorts.py
View File

@@ -248,13 +248,13 @@ class TestCohorts(ModuleStoreTestCase):
# Make the course cohorted...
config_course_cohorts(course, is_cohorted=True)
self.assertEquals(
self.assertEqual(
cohorts.get_cohort(user, course.id).id,
cohort.id,
"user should be assigned to the correct cohort"
)
self.assertEquals(
self.assertEqual(
cohorts.get_cohort(other_user, course.id).id,
cohorts.get_cohort_by_name(course.id, cohorts.DEFAULT_COHORT_NAME).id,
"other_user should be assigned to the default cohort"
@@ -272,14 +272,14 @@ class TestCohorts(ModuleStoreTestCase):
# Add email address to the cohort
(user, previous_cohort, prereg) = cohorts.add_user_to_cohort(cohort, "email@example.com")
self.assertEquals(
self.assertEqual(
(user, previous_cohort, prereg),
(None, None, True)
)
# Create user with this email address
user = UserFactory(username="test", email="email@example.com")
self.assertEquals(
self.assertEqual(
cohorts.get_cohort(user, course.id).id,
cohort.id,
"User should be assigned to the right cohort"
@@ -298,21 +298,21 @@ class TestCohorts(ModuleStoreTestCase):
# Add email address to the first cohort
(user, previous_cohort, prereg) = cohorts.add_user_to_cohort(cohort, "email@example.com")
self.assertEquals(
self.assertEqual(
(user, previous_cohort, prereg),
(None, None, True)
)
# Add email address to the second cohort
(user, previous_cohort, prereg) = cohorts.add_user_to_cohort(cohort2, "email@example.com")
self.assertEquals(
self.assertEqual(
(user, previous_cohort, prereg),
(None, None, True)
)
# Create user with this email address
user = UserFactory(username="test", email="email@example.com")
self.assertEquals(
self.assertEqual(
cohorts.get_cohort(user, course.id).id,
cohort2.id,
"User should be assigned to the right cohort"
@@ -357,7 +357,7 @@ class TestCohorts(ModuleStoreTestCase):
self.assertIsNone(cohorts.get_cohort(user, course.id, assign=False))
# get_cohort should return a group for user
self.assertEquals(cohorts.get_cohort(user, course.id).name, "AutoGroup")
self.assertEqual(cohorts.get_cohort(user, course.id).name, "AutoGroup")
def test_cohorting_with_auto_cohorts(self):
"""
@@ -379,9 +379,9 @@ class TestCohorts(ModuleStoreTestCase):
auto_cohorts=["AutoGroup"]
)
self.assertEquals(cohorts.get_cohort(user1, course.id).id, cohort.id, "user1 should stay put")
self.assertEqual(cohorts.get_cohort(user1, course.id).id, cohort.id, "user1 should stay put")
self.assertEquals(cohorts.get_cohort(user2, course.id).name, "AutoGroup", "user2 should be auto-cohorted")
self.assertEqual(cohorts.get_cohort(user2, course.id).name, "AutoGroup", "user2 should be auto-cohorted")
def test_anonymous_user_cohort(self):
"""
@@ -416,7 +416,7 @@ class TestCohorts(ModuleStoreTestCase):
auto_cohorts=["AutoGroup"]
)
self.assertEquals(cohorts.get_cohort(user1, course.id).name, "AutoGroup", "user1 should be auto-cohorted")
self.assertEqual(cohorts.get_cohort(user1, course.id).name, "AutoGroup", "user1 should be auto-cohorted")
# Now set the auto_cohort_group to something different
# This will have no effect on lms side as we are already done with migrations
@@ -426,11 +426,11 @@ class TestCohorts(ModuleStoreTestCase):
auto_cohort_groups=["OtherGroup"]
)
self.assertEquals(
self.assertEqual(
cohorts.get_cohort(user2, course.id).name, "AutoGroup", "user2 should be assigned to AutoGroups"
)
self.assertEquals(
self.assertEqual(
cohorts.get_cohort(user1, course.id).name, "AutoGroup", "user1 should still be in originally placed cohort"
)
@@ -454,7 +454,7 @@ class TestCohorts(ModuleStoreTestCase):
auto_cohorts=[]
)
self.assertEquals(
self.assertEqual(
cohorts.get_cohort(user1, course.id).id,
cohorts.get_cohort_by_name(course.id, cohorts.DEFAULT_COHORT_NAME).id,
"No groups->default cohort for user1"
@@ -468,13 +468,13 @@ class TestCohorts(ModuleStoreTestCase):
auto_cohort_groups=["AutoGroup"]
)
self.assertEquals(
self.assertEqual(
cohorts.get_cohort(user1, course.id).name,
cohorts.get_cohort_by_name(course.id, cohorts.DEFAULT_COHORT_NAME).name,
"user1 should still be in the default cohort"
)
self.assertEquals(
self.assertEqual(
cohorts.get_cohort(user2, course.id).id,
cohorts.get_cohort_by_name(course.id, cohorts.DEFAULT_COHORT_NAME).id,
"No groups->default cohort for user2"

6
openedx/core/djangoapps/course_groups/tests/test_partition_scheme.py
View File

@@ -229,7 +229,7 @@ class TestCohortPartitionScheme(ModuleStoreTestCase):
with patch('openedx.core.djangoapps.course_groups.partition_scheme.log') as mock_log:
self.assert_student_in_group(None, new_user_partition)
self.assertTrue(mock_log.warn.called)
self.assertRegexpMatches(mock_log.warn.call_args[0][0], 'group not found')
self.assertRegex(mock_log.warn.call_args[0][0], 'group not found')
def test_missing_partition(self):
"""
@@ -254,7 +254,7 @@ class TestCohortPartitionScheme(ModuleStoreTestCase):
with patch('openedx.core.djangoapps.course_groups.partition_scheme.log') as mock_log:
self.assert_student_in_group(None, new_user_partition)
self.assertTrue(mock_log.warn.called)
self.assertRegexpMatches(mock_log.warn.call_args[0][0], 'partition mismatch')
self.assertRegex(mock_log.warn.call_args[0][0], 'partition mismatch')
class TestExtension(django.test.TestCase):
@@ -265,7 +265,7 @@ class TestExtension(django.test.TestCase):
def test_get_scheme(self):
self.assertEqual(UserPartition.get_scheme('cohort'), CohortPartitionScheme)
with self.assertRaisesRegexp(UserPartitionError, 'Unrecognized scheme'):
with self.assertRaisesRegex(UserPartitionError, 'Unrecognized scheme'):
UserPartition.get_scheme('other')

4
openedx/core/djangoapps/dark_lang/tests.py
View File

@@ -77,7 +77,7 @@ class DarkLangMiddlewareTests(CacheIsolationTestCase):
Assert that the HTML_ACCEPT_LANGUAGE header in request
is equal to value
"""
self.assertEquals(
self.assertEqual(
value,
request.META.get('HTTP_ACCEPT_LANGUAGE', UNSET)
)
@@ -237,7 +237,7 @@ class DarkLangMiddlewareTests(CacheIsolationTestCase):
"""
Assert that the LANGUAGE_SESSION_KEY set in session is equal to value
"""
self.assertEquals(
self.assertEqual(
value,
session.get(LANGUAGE_SESSION_KEY, UNSET)
)

8
openedx/core/djangoapps/embargo/tests/test_forms.py
View File

@@ -50,7 +50,7 @@ class RestrictedCourseFormTest(ModuleStoreTestCase):
msg = 'COURSE NOT FOUND'
self.assertIn(msg, form._errors['course_key'][0]) # pylint: disable=protected-access
with self.assertRaisesRegexp(
with self.assertRaisesRegex(
ValueError, "The RestrictedCourse could not be created because the data didn't validate."
):
form.save()
@@ -123,7 +123,7 @@ class IPFilterFormTest(TestCase):
else:
wmsg = "Invalid IP Address(es): ['.0.0.1', ':dead:beef:::', '1.0.0.0/55']" \
" Please fix the error(s) and try again."
self.assertEquals(wmsg, form._errors['whitelist'][0]) # pylint: disable=protected-access
self.assertEqual(wmsg, form._errors['whitelist'][0]) # pylint: disable=protected-access
if six.PY2:
bmsg = "Invalid IP Address(es): [u'18.244.*', u'999999:c0a8:101::42', u'1.0.0.0/']" \
@@ -131,7 +131,7 @@ class IPFilterFormTest(TestCase):
else:
bmsg = "Invalid IP Address(es): ['18.244.*', '999999:c0a8:101::42', '1.0.0.0/']" \
" Please fix the error(s) and try again."
self.assertEquals(bmsg, form._errors['blacklist'][0]) # pylint: disable=protected-access
self.assertEqual(bmsg, form._errors['blacklist'][0]) # pylint: disable=protected-access
with self.assertRaisesRegexp(ValueError, "The IPFilter could not be created because the data didn't validate."):
with self.assertRaisesRegex(ValueError, "The IPFilter could not be created because the data didn't validate."):
form.save()

12
openedx/core/djangoapps/embargo/tests/test_models.py
View File

@@ -37,7 +37,7 @@ class EmbargoModelsTest(CacheIsolationTestCase):
# Now, course should be embargoed
self.assertTrue(EmbargoedCourse.is_embargoed(course_id))
self.assertEquals(
self.assertEqual(
six.text_type(cauth),
u"Course '{course_id}' is Embargoed".format(course_id=course_id)
)
@@ -47,7 +47,7 @@ class EmbargoModelsTest(CacheIsolationTestCase):
cauth.save()
# Test that course is now unauthorized
self.assertFalse(EmbargoedCourse.is_embargoed(course_id))
self.assertEquals(
self.assertEqual(
six.text_type(cauth),
u"Course '{course_id}' is Not Embargoed".format(course_id=course_id)
)
@@ -124,7 +124,7 @@ class RestrictedCourseTest(CacheIsolationTestCase):
def test_unicode_values(self):
course_id = CourseLocator('abc', '123', 'doremi')
restricted_course = RestrictedCourse.objects.create(course_key=course_id)
self.assertEquals(
self.assertEqual(
six.text_type(restricted_course),
six.text_type(course_id)
)
@@ -176,7 +176,7 @@ class CountryTest(TestCase):
def test_unicode_values(self):
country = Country.objects.create(country='NZ')
self.assertEquals(six.text_type(country), "New Zealand (NZ)")
self.assertEqual(six.text_type(country), "New Zealand (NZ)")
class CountryAccessRuleTest(CacheIsolationTestCase):
@@ -193,7 +193,7 @@ class CountryAccessRuleTest(CacheIsolationTestCase):
country=country
)
self.assertEquals(
self.assertEqual(
six.text_type(access_rule),
u"Whitelist New Zealand (NZ) for {course_key}".format(course_key=course_id)
)
@@ -206,7 +206,7 @@ class CountryAccessRuleTest(CacheIsolationTestCase):
country=country
)
self.assertEquals(
self.assertEqual(
six.text_type(access_rule),
u"Blacklist New Zealand (NZ) for {course_key}".format(course_key=course_id)
)

52
openedx/core/djangoapps/enrollments/tests/test_api.py
View File

@@ -57,12 +57,12 @@ class EnrollmentTest(CacheIsolationTestCase):
# Enroll in the course and verify the URL we get sent to
result = api.add_enrollment(self.USERNAME, self.COURSE_ID, mode=mode)
self.assertIsNotNone(result)
self.assertEquals(result['student'], self.USERNAME)
self.assertEquals(result['course']['course_id'], self.COURSE_ID)
self.assertEquals(result['mode'], mode)
self.assertEqual(result['student'], self.USERNAME)
self.assertEqual(result['course']['course_id'], self.COURSE_ID)
self.assertEqual(result['mode'], mode)
get_result = api.get_enrollment(self.USERNAME, self.COURSE_ID)
self.assertEquals(result, get_result)
self.assertEqual(result, get_result)
@ddt.data(
([CourseMode.DEFAULT_MODE_SLUG, 'verified', 'credit'], CourseMode.DEFAULT_MODE_SLUG),
@@ -79,9 +79,9 @@ class EnrollmentTest(CacheIsolationTestCase):
# Enroll in the course and verify the URL we get sent to
result = api.add_enrollment(self.USERNAME, self.COURSE_ID)
self.assertIsNotNone(result)
self.assertEquals(result['student'], self.USERNAME)
self.assertEquals(result['course']['course_id'], self.COURSE_ID)
self.assertEquals(result['mode'], expected_mode)
self.assertEqual(result['student'], self.USERNAME)
self.assertEqual(result['course']['course_id'], self.COURSE_ID)
self.assertEqual(result['mode'], expected_mode)
@ddt.data(
['professional'],
@@ -123,16 +123,16 @@ class EnrollmentTest(CacheIsolationTestCase):
# Enroll in the course and verify the URL we get sent to
result = api.add_enrollment(self.USERNAME, self.COURSE_ID, mode=mode)
self.assertIsNotNone(result)
self.assertEquals(result['student'], self.USERNAME)
self.assertEquals(result['course']['course_id'], self.COURSE_ID)
self.assertEquals(result['mode'], mode)
self.assertEqual(result['student'], self.USERNAME)
self.assertEqual(result['course']['course_id'], self.COURSE_ID)
self.assertEqual(result['mode'], mode)
self.assertTrue(result['is_active'])
result = api.update_enrollment(self.USERNAME, self.COURSE_ID, mode=mode, is_active=False)
self.assertIsNotNone(result)
self.assertEquals(result['student'], self.USERNAME)
self.assertEquals(result['course']['course_id'], self.COURSE_ID)
self.assertEquals(result['mode'], mode)
self.assertEqual(result['student'], self.USERNAME)
self.assertEqual(result['course']['course_id'], self.COURSE_ID)
self.assertEqual(result['mode'], mode)
self.assertFalse(result['is_active'])
def test_unenroll_not_enrolled_in_course(self):
@@ -174,13 +174,13 @@ class EnrollmentTest(CacheIsolationTestCase):
# Enroll in the course and verify the URL we get sent to
result = api.add_enrollment(self.USERNAME, self.COURSE_ID, mode='audit')
get_result = api.get_enrollment(self.USERNAME, self.COURSE_ID)
self.assertEquals(result, get_result)
self.assertEqual(result, get_result)
result = api.update_enrollment(self.USERNAME, self.COURSE_ID, mode='honor')
self.assertEquals('honor', result['mode'])
self.assertEqual('honor', result['mode'])
result = api.update_enrollment(self.USERNAME, self.COURSE_ID, mode='verified')
self.assertEquals('verified', result['mode'])
self.assertEqual('verified', result['mode'])
def test_update_enrollment_attributes(self):
# Add fake course enrollment information to the fake data API
@@ -188,7 +188,7 @@ class EnrollmentTest(CacheIsolationTestCase):
# Enroll in the course and verify the URL we get sent to
result = api.add_enrollment(self.USERNAME, self.COURSE_ID, mode='audit')
get_result = api.get_enrollment(self.USERNAME, self.COURSE_ID)
self.assertEquals(result, get_result)
self.assertEqual(result, get_result)
enrollment_attributes = [
{
@@ -201,16 +201,16 @@ class EnrollmentTest(CacheIsolationTestCase):
result = api.update_enrollment(
self.USERNAME, self.COURSE_ID, mode='credit', enrollment_attributes=enrollment_attributes
)
self.assertEquals('credit', result['mode'])
self.assertEqual('credit', result['mode'])
attributes = api.get_enrollment_attributes(self.USERNAME, self.COURSE_ID)
self.assertEquals(enrollment_attributes[0], attributes[0])
self.assertEqual(enrollment_attributes[0], attributes[0])
def test_get_course_details(self):
# Add a fake course enrollment information to the fake data API
fake_data_api.add_course(self.COURSE_ID, course_modes=['honor', 'verified', 'audit'])
result = api.get_course_enrollment_details(self.COURSE_ID)
self.assertEquals(result['course_id'], self.COURSE_ID)
self.assertEquals(3, len(result['course_modes']))
self.assertEqual(result['course_id'], self.COURSE_ID)
self.assertEqual(3, len(result['course_modes']))
@override_settings(ENROLLMENT_DATA_API='foo.bar.biz.baz')
def test_data_api_config_error(self):
@@ -261,7 +261,7 @@ class EnrollmentTest(CacheIsolationTestCase):
fake_data_api.add_course(self.COURSE_ID, course_modes=['honor', 'verified', 'audit'])
result = api.add_enrollment(self.USERNAME, self.COURSE_ID, mode=enrollment_mode)
get_result = api.get_enrollment(self.USERNAME, self.COURSE_ID)
self.assertEquals(result, get_result)
self.assertEqual(result, get_result)
# set the course verify mode as expire.
fake_data_api.set_expired_mode(self.COURSE_ID)
@@ -271,11 +271,11 @@ class EnrollmentTest(CacheIsolationTestCase):
result = api.update_enrollment(
self.USERNAME, self.COURSE_ID, mode=mode, is_active=is_active, include_expired=include_expired
)
self.assertEquals(mode, result['mode'])
self.assertEqual(mode, result['mode'])
self.assertIsNotNone(result)
self.assertEquals(result['student'], self.USERNAME)
self.assertEquals(result['course']['course_id'], self.COURSE_ID)
self.assertEquals(result['mode'], mode)
self.assertEqual(result['student'], self.USERNAME)
self.assertEqual(result['course']['course_id'], self.COURSE_ID)
self.assertEqual(result['mode'], mode)
if is_active:
self.assertTrue(result['is_active'])

4
openedx/core/djangoapps/enrollments/tests/test_views.py
View File

@@ -273,7 +273,7 @@ class EnrollmentTest(EnrollmentTestMixin, ModuleStoreTestCase, APITestCase, Ente
_assert_no_opt_in_set()
else:
preference = UserOrgTag.objects.get(user=self.user, org=self.course.id.org, key="email-optin")
self.assertEquals(preference.value, pref_value)
self.assertEqual(preference.value, pref_value)
def test_enroll_prof_ed(self):
# Create the prod ed mode.
@@ -946,7 +946,7 @@ class EnrollmentTest(EnrollmentTestMixin, ModuleStoreTestCase, APITestCase, Ente
self.assertEqual(is_active, old_is_active)
self.assertEqual(course_mode, old_mode)
# error message should contain specific text. Otto checks for this text in the message.
self.assertRegexpMatches(
self.assertRegex(
json.loads(response.content.decode('utf-8'))['message'],
'Enrollment mode mismatch'
)

16
openedx/core/djangoapps/header_control/tests/test_middleware.py
View File

@@ -22,8 +22,8 @@ class TestHeaderControlMiddlewareProcessResponse(TestCase):
fake_response['Accept-Encoding'] = 'gzip'
result = self.middleware.process_response(fake_request, fake_response)
self.assertEquals('Cookie', result['Vary'])
self.assertEquals('gzip', result['Accept-Encoding'])
self.assertEqual('Cookie', result['Vary'])
self.assertEqual('gzip', result['Accept-Encoding'])
def test_doesnt_barf_removing_nonexistent_headers(self):
fake_request = HttpRequest()
@@ -35,7 +35,7 @@ class TestHeaderControlMiddlewareProcessResponse(TestCase):
result = self.middleware.process_response(fake_request, fake_response)
self.assertNotIn('Vary', result)
self.assertEquals('gzip', result['Accept-Encoding'])
self.assertEqual('gzip', result['Accept-Encoding'])
def test_removes_intended_headers(self):
fake_request = HttpRequest()
@@ -47,7 +47,7 @@ class TestHeaderControlMiddlewareProcessResponse(TestCase):
result = self.middleware.process_response(fake_request, fake_response)
self.assertNotIn('Vary', result)
self.assertEquals('gzip', result['Accept-Encoding'])
self.assertEqual('gzip', result['Accept-Encoding'])
def test_forces_intended_header(self):
fake_request = HttpRequest()
@@ -58,8 +58,8 @@ class TestHeaderControlMiddlewareProcessResponse(TestCase):
force_header_for_response(fake_response, 'Vary', 'Origin')
result = self.middleware.process_response(fake_request, fake_response)
self.assertEquals('Origin', result['Vary'])
self.assertEquals('gzip', result['Accept-Encoding'])
self.assertEqual('Origin', result['Vary'])
self.assertEqual('gzip', result['Accept-Encoding'])
def test_does_not_mangle_undecorated_response(self):
fake_request = HttpRequest()
@@ -69,5 +69,5 @@ class TestHeaderControlMiddlewareProcessResponse(TestCase):
fake_response['Accept-Encoding'] = 'gzip'
result = self.middleware.process_response(fake_request, fake_response)
self.assertEquals('Cookie', result['Vary'])
self.assertEquals('gzip', result['Accept-Encoding'])
self.assertEqual('Cookie', result['Vary'])
self.assertEqual('gzip', result['Accept-Encoding'])

2
openedx/core/djangoapps/lang_pref/tests/test_middleware.py
View File

@@ -155,7 +155,7 @@ class TestUserPreferenceMiddleware(CacheIsolationTestCase):
else:
self.assertEqual(accept_lang_result, accept_lang_out)
self.assertEquals(self.request.session.get(LANGUAGE_SESSION_KEY), lang_session_out)
self.assertEqual(self.request.session.get(LANGUAGE_SESSION_KEY), lang_session_out)
@ddt.data(None, 'es', 'en')
def test_logout_preserves_cookie(self, lang_cookie):

4
openedx/core/djangoapps/lang_pref/tests/test_views.py
View File

@@ -32,9 +32,9 @@ class TestLangPrefView(TestCase):
response = self.client.patch(reverse("session_language"), json.dumps({'pref-lang': 'eo'}))
self.assertEqual(response.status_code, 200)
self.client.get('/')
self.assertEquals(get_language(), 'eo')
self.assertEqual(get_language(), 'eo')
response = self.client.patch(reverse("session_language"), json.dumps({'pref-lang': 'en'}))
self.assertEqual(response.status_code, 200)
self.client.get('/')
self.assertEquals(get_language(), 'en')
self.assertEqual(get_language(), 'en')

2
openedx/core/djangoapps/models/tests/test_course_details.py
View File

@@ -179,4 +179,4 @@ class CourseDetailsTestCase(ModuleStoreTestCase):
CourseDetails.update_about_video(self.course, video_value, self.user.id)
self.assertEqual(CourseDetails.fetch_youtube_video_id(self.course.id), video_value)
video_url = CourseDetails.fetch_video_url(self.course.id)
self.assertRegexpMatches(video_url, r'http://.*{}'.format(video_value))
self.assertRegex(video_url, r'http://.*{}'.format(video_value))

22
openedx/core/djangoapps/safe_sessions/tests/test_middleware.py
View File

@@ -50,7 +50,7 @@ class TestSafeSessionProcessRequest(TestSafeSessionsLogMixin, TestCase):
self.assertIsNone(response)
self.assertIsNone(getattr(self.request, 'need_to_delete_cookie', None))
else:
self.assertEquals(response.status_code, HttpResponseRedirect.status_code)
self.assertEqual(response.status_code, HttpResponseRedirect.status_code)
self.assertTrue(self.request.need_to_delete_cookie)
def assert_no_session(self):
@@ -69,7 +69,7 @@ class TestSafeSessionProcessRequest(TestSafeSessionsLogMixin, TestCase):
"""
Asserts that a user object *is* set on the request's session.
"""
self.assertEquals(
self.assertEqual(
SafeSessionMiddleware.get_user_id_from_session(self.request),
self.user.id
)
@@ -88,13 +88,13 @@ class TestSafeSessionProcessRequest(TestSafeSessionsLogMixin, TestCase):
self.assert_user_in_session()
# verify step 2: cookie value is replaced with parsed session_id
self.assertEquals(self.request.COOKIES[settings.SESSION_COOKIE_NAME], session_id)
self.assertEqual(self.request.COOKIES[settings.SESSION_COOKIE_NAME], session_id)
# verify step 3: session set in request
self.assertIsNotNone(self.request.session)
# verify steps 4, 5: user_id stored for later verification
self.assertEquals(self.request.safe_cookie_verified_user_id, self.user.id)
self.assertEqual(self.request.safe_cookie_verified_user_id, self.user.id)
def test_success_no_cookies(self):
self.assert_response()
@@ -156,7 +156,7 @@ class TestSafeSessionProcessResponse(TestSafeSessionsLogMixin, TestCase):
self.client.response.cookies[settings.SESSION_COOKIE_NAME] = "some_session_id"
response = SafeSessionMiddleware().process_response(self.request, self.client.response)
self.assertEquals(response.status_code, 200)
self.assertEqual(response.status_code, 200)
def assert_response_with_delete_cookie(
self,
@@ -174,7 +174,7 @@ class TestSafeSessionProcessResponse(TestSafeSessionsLogMixin, TestCase):
"""
with patch('django.http.HttpResponse.set_cookie') as mock_delete_cookie:
self.assert_response(set_request_user=set_request_user, set_session_cookie=set_session_cookie)
self.assertEquals(mock_delete_cookie.called, expect_delete_called)
self.assertEqual(mock_delete_cookie.called, expect_delete_called)
def test_success(self):
with self.assert_not_logged():
@@ -207,8 +207,8 @@ class TestSafeSessionProcessResponse(TestSafeSessionsLogMixin, TestCase):
serialized_cookie_data = self.client.response.cookies[settings.SESSION_COOKIE_NAME].value
safe_cookie_data = SafeCookieData.parse(serialized_cookie_data)
self.assertEquals(safe_cookie_data.version, SafeCookieData.CURRENT_VERSION)
self.assertEquals(safe_cookie_data.session_id, "some_session_id")
self.assertEqual(safe_cookie_data.version, SafeCookieData.CURRENT_VERSION)
self.assertEqual(safe_cookie_data.session_id, "some_session_id")
self.assertTrue(safe_cookie_data.verify(self.user.id))
def test_cant_update_cookie_at_step_3_error(self):
@@ -267,12 +267,12 @@ class TestSafeSessionMiddleware(TestSafeSessionsLogMixin, TestCase):
response = SafeSessionMiddleware().process_request(self.request)
self.assertIsNone(response)
self.assertEquals(self.request.safe_cookie_verified_user_id, self.user.id)
self.assertEqual(self.request.safe_cookie_verified_user_id, self.user.id)
self.cookies_from_request_to_response()
with self.assert_not_logged():
response = SafeSessionMiddleware().process_response(self.request, self.client.response)
self.assertEquals(response.status_code, 200)
self.assertEqual(response.status_code, 200)
def test_success(self):
self.verify_success()
@@ -294,7 +294,7 @@ class TestSafeSessionMiddleware(TestSafeSessionsLogMixin, TestCase):
with self.assert_parse_error():
request_response = SafeSessionMiddleware().process_request(self.request)
self.assertEquals(request_response.status_code, expected_response_status)
self.assertEqual(request_response.status_code, expected_response_status)
self.assertTrue(self.request.need_to_delete_cookie)
self.cookies_from_request_to_response()

2
openedx/core/djangoapps/safe_sessions/tests/test_safe_cookie_data.py
View File

@@ -62,7 +62,7 @@ class TestSafeCookieData(TestSafeSessionsLogMixin, TestCase):
self.assert_cookie_data_equal(safe_cookie_data_1, safe_cookie_data_2)
def test_version(self):
self.assertEquals(self.safe_cookie_data.version, SafeCookieData.CURRENT_VERSION)
self.assertEqual(self.safe_cookie_data.version, SafeCookieData.CURRENT_VERSION)
def test_serialize(self):
serialized_value = six.text_type(self.safe_cookie_data)

2
openedx/core/djangoapps/safe_sessions/tests/test_utils.py
View File

@@ -23,7 +23,7 @@ class TestSafeSessionsLogMixin(object):
with patch('openedx.core.djangoapps.safe_sessions.middleware.log.' + log_level) as mock_log:
yield
self.assertTrue(mock_log.called)
self.assertRegexpMatches(mock_log.call_args_list[0][0][0], log_string)
self.assertRegex(mock_log.call_args_list[0][0][0], log_string)
@contextmanager
def assert_logged_with_message(self, log_string, log_level='error'):

4
openedx/core/djangoapps/site_configuration/management/commands/tests/test_create_site_configuration.py
View File

@@ -31,8 +31,8 @@ class TestCreateSiteConfiguration(TestCase):
)
site = Site.objects.get(domain__contains=self.site_domain)
self.assertEquals(site.name, self.site_domain)
self.assertEquals(site.domain, self.site_domain)
self.assertEqual(site.name, self.site_domain)
self.assertEqual(site.domain, self.site_domain)
self._validate_site_configuration(site)

4
openedx/core/djangoapps/theming/tests/test_views.py
View File

@@ -87,7 +87,7 @@ class TestThemingViews(TestCase):
# Next request a page and verify that the correct theme has been chosen
response = self.client.get(THEMING_ADMIN_URL)
self.assertEquals(response.status_code, 200)
self.assertEqual(response.status_code, 200)
self.assertContains(
response,
u'<option value="{theme_name}" selected=selected>'.format(theme_name=TEST_THEME_NAME)
@@ -104,7 +104,7 @@ class TestThemingViews(TestCase):
# Finally verify that the test theme is no longer selected
response = self.client.get(THEMING_ADMIN_URL)
self.assertEquals(response.status_code, 200)
self.assertEqual(response.status_code, 200)
self.assertContains(
response,
u'<option value="{theme_name}">'.format(theme_name=TEST_THEME_NAME)

2
openedx/core/djangoapps/user_api/accounts/tests/test_views.py
View File

@@ -294,7 +294,7 @@ class TestAccountsAPI(CacheIsolationTestCase, UserAPITestCase):
self.assertEqual("world peace", data["goals"])
self.assertTrue(data["is_active"])
self.assertEqual("Park Ave", data['mailing_address'])
self.assertEquals(requires_parental_consent, data["requires_parental_consent"])
self.assertEqual(requires_parental_consent, data["requires_parental_consent"])
self.assertIsNone(data["secondary_email"])
self.assertEqual(year_of_birth, data["year_of_birth"])

6
openedx/core/djangoapps/user_api/management/tests/test_email_opt_in_list.py
View File

@@ -189,7 +189,7 @@ class EmailOptInListTest(ModuleStoreTestCase):
self._set_opt_in_pref(self.user, self.TEST_ORG, True)
# No course available for this particular org
with self.assertRaisesRegexp(CommandError, "^No courses found for orgs:"):
with self.assertRaisesRegex(CommandError, "^No courses found for orgs:"):
self._run_command("other_org")
def test_specify_subset_of_courses(self):
@@ -282,7 +282,7 @@ class EmailOptInListTest(ModuleStoreTestCase):
expected_msg_regex = (
"^Error: the following arguments are required: OUTPUT_FILENAME, ORG_ALIASES$"
)
with self.assertRaisesRegexp(CommandError, expected_msg_regex):
with self.assertRaisesRegex(CommandError, expected_msg_regex):
call_command('email_opt_in_list', *args)
def test_file_already_exists(self):
@@ -291,7 +291,7 @@ class EmailOptInListTest(ModuleStoreTestCase):
def _cleanup():
temp_file.close()
with self.assertRaisesRegexp(CommandError, "^File already exists"):
with self.assertRaisesRegex(CommandError, "^File already exists"):
call_command('email_opt_in_list', temp_file.name, self.TEST_ORG)
def test_no_user_profile(self):

4
openedx/core/djangoapps/user_api/preferences/tests/test_views.py
View File

@@ -237,7 +237,7 @@ class TestPreferencesAPI(UserAPITestCase):
)
self.assertTrue(response.data.get("field_errors", None))
field_errors = response.data["field_errors"]
self.assertEquals(
self.assertEqual(
field_errors,
{
TOO_LONG_PREFERENCE_KEY: {
@@ -519,7 +519,7 @@ class TestPreferencesDetailAPI(UserAPITestCase):
new_value = "new value"
self._set_url(too_long_preference_key)
response = self.send_put(self.client, new_value, expected_status=400)
self.assertEquals(
self.assertEqual(
response.data,
{
"developer_message": get_expected_validation_developer_message(too_long_preference_key, new_value),

6
openedx/core/djangoapps/user_api/tests/test_middleware.py
View File

@@ -42,7 +42,7 @@ class TagsMiddlewareTest(TestCase):
so that the request continues.
"""
# Middleware should pass request through
self.assertEquals(self.middleware.process_request(self.request), None)
self.assertEqual(self.middleware.process_request(self.request), None)
def assertContextSetTo(self, context):
"""Asserts UserTagsEventContextMiddleware.CONTEXT_NAME matches ``context``"""
@@ -114,7 +114,7 @@ class TagsMiddlewareTest(TestCase):
exit_context = get_tracker.return_value.exit_context
# The middleware should clean up the context when the request is done
self.assertEquals(
self.assertEqual(
self.middleware.process_response(self.request, self.response),
self.response
)
@@ -123,7 +123,7 @@ class TagsMiddlewareTest(TestCase):
# Even if the tracker blows up, the middleware should still return the response
get_tracker.side_effect = Exception
self.assertEquals(
self.assertEqual(
self.middleware.process_response(self.request, self.response),
self.response
)

18
openedx/core/djangoapps/user_api/tests/test_models.py
View File

@@ -55,20 +55,20 @@ class UserPreferenceModelTest(ModuleStoreTestCase):
user = UserFactory.create()
course = CourseFactory.create()
tag = UserCourseTagFactory.create(user=user, course_id=course.id, key="testkey", value="foobar")
self.assertEquals(tag.user, user)
self.assertEquals(tag.course_id, course.id)
self.assertEquals(tag.key, "testkey")
self.assertEquals(tag.value, "foobar")
self.assertEqual(tag.user, user)
self.assertEqual(tag.course_id, course.id)
self.assertEqual(tag.key, "testkey")
self.assertEqual(tag.value, "foobar")
def test_create_user_org_tags(self):
"""Create org specific user tags and confirm all properties are set """
user = UserFactory.create()
course = CourseFactory.create()
tag = UserOrgTagFactory.create(user=user, org=course.id.org, key="testkey", value="foobar")
self.assertEquals(tag.user, user)
self.assertEquals(tag.org, course.id.org)
self.assertEquals(tag.key, "testkey")
self.assertEquals(tag.value, "foobar")
self.assertEqual(tag.user, user)
self.assertEqual(tag.org, course.id.org)
self.assertEqual(tag.key, "testkey")
self.assertEqual(tag.value, "foobar")
self.assertIsNotNone(tag.created)
self.assertIsNotNone(tag.modified)
@@ -76,7 +76,7 @@ class UserPreferenceModelTest(ModuleStoreTestCase):
original_modified = tag.modified
tag.value = "barfoo"
tag.save()
self.assertEquals(tag.value, "barfoo")
self.assertEqual(tag.value, "barfoo")
self.assertNotEqual(original_modified, tag.modified)
def test_retire_user_org_tags_by_user_value(self):

4
openedx/core/djangoapps/user_api/tests/test_partition_schemes.py
View File

@@ -98,7 +98,7 @@ class TestRandomUserPartitionScheme(PartitionTestCase):
scheme=RandomUserPartitionScheme
)
# get a group assigned to the user
with self.assertRaisesRegexp(UserPartitionError, "Cannot assign user to an empty user partition"):
with self.assertRaisesRegex(UserPartitionError, "Cannot assign user to an empty user partition"):
RandomUserPartitionScheme.get_group_for_user(self.MOCK_COURSE_ID, self.user, empty_partition)
def test_user_in_deleted_group(self):
@@ -147,5 +147,5 @@ class TestExtension(TestCase):
def test_get_scheme(self):
self.assertEqual(UserPartition.get_scheme('random'), RandomUserPartitionScheme)
with self.assertRaisesRegexp(UserPartitionError, 'Unrecognized scheme'):
with self.assertRaisesRegex(UserPartitionError, 'Unrecognized scheme'):
UserPartition.get_scheme('other')

4
openedx/core/djangoapps/user_api/tests/test_views.py
View File

@@ -611,7 +611,7 @@ class UpdateEmailOptInTestCase(UserAPITestCase, SharedModuleStoreTestCase):
preference = UserOrgTag.objects.get(
user=self.user, org=self.course.id.org, key="email-optin"
)
self.assertEquals(preference.value, result)
self.assertEqual(preference.value, result)
@ddt.data(
(True, False),
@@ -643,7 +643,7 @@ class UpdateEmailOptInTestCase(UserAPITestCase, SharedModuleStoreTestCase):
preference = UserOrgTag.objects.get(
user=self.user, org=self.course.id.org, key="email-optin"
)
self.assertEquals(preference.value, u"True")
self.assertEqual(preference.value, u"True")
def test_update_email_opt_in_anonymous_user(self):
"""

8
openedx/core/djangoapps/user_authn/views/tests/test_login.py
View File

@@ -531,8 +531,8 @@ class LoginTest(SiteMixin, CacheIsolationTestCase):
"""
method_calls = mock_audit_log.method_calls
name, args, _kwargs = method_calls[-1]
self.assertEquals(name, level)
self.assertEquals(len(args), 1)
self.assertEqual(name, level)
self.assertEqual(len(args), 1)
format_string = args[0]
for log_string in log_strings:
self.assertIn(log_string, format_string)
@@ -543,8 +543,8 @@ class LoginTest(SiteMixin, CacheIsolationTestCase):
"""
method_calls = mock_audit_log.method_calls
name, args, _kwargs = method_calls[-1]
self.assertEquals(name, level)
self.assertEquals(len(args), 1)
self.assertEqual(name, level)
self.assertEqual(len(args), 1)
format_string = args[0]
for log_string in log_strings:
self.assertNotIn(log_string, format_string)

6
openedx/core/djangoapps/user_authn/views/tests/test_register.py
View File

@@ -1741,15 +1741,15 @@ class ThirdPartyRegistrationTestMixin(ThirdPartyOAuthTestMixin, CacheIsolationTe
def _verify_user_existence(self, user_exists, social_link_exists, user_is_active=None, username=None):
"""Verifies whether the user object exists."""
users = User.objects.filter(username=(username if username else "test_username"))
self.assertEquals(users.exists(), user_exists)
self.assertEqual(users.exists(), user_exists)
if user_exists:
self.assertEquals(users[0].is_active, user_is_active)
self.assertEqual(users[0].is_active, user_is_active)
self.assertEqual(
UserSocialAuth.objects.filter(user=users[0], provider=self.BACKEND).exists(),
social_link_exists
)
else:
self.assertEquals(UserSocialAuth.objects.count(), 0)
self.assertEqual(UserSocialAuth.objects.count(), 0)
def test_success(self):
self._verify_user_existence(user_exists=False, social_link_exists=False)

20
openedx/core/djangoapps/user_authn/views/tests/test_reset_password.py
View File

@@ -83,9 +83,9 @@ class ResetPasswordTests(EventTestMixin, CacheIsolationTestCase):
bad_pwd_req = self.request_factory.post('/password_reset/', {'email': self.user_bad_passwd.email})
bad_pwd_resp = password_reset(bad_pwd_req)
# If they've got an unusable password, we return a successful response code
self.assertEquals(bad_pwd_resp.status_code, 200)
self.assertEqual(bad_pwd_resp.status_code, 200)
obj = json.loads(bad_pwd_resp.content.decode('utf-8'))
self.assertEquals(obj, {
self.assertEqual(obj, {
'success': True,
'value': "('registration/password_reset_done.html', [])",
})
@@ -105,9 +105,9 @@ class ResetPasswordTests(EventTestMixin, CacheIsolationTestCase):
# Note: even if the email is bad, we return a successful response code
# This prevents someone potentially trying to "brute-force" find out which
# emails are and aren't registered with edX
self.assertEquals(bad_email_resp.status_code, 200)
self.assertEqual(bad_email_resp.status_code, 200)
obj = json.loads(bad_email_resp.content.decode('utf-8'))
self.assertEquals(obj, {
self.assertEqual(obj, {
'success': True,
'value': "('registration/password_reset_done.html', [])",
})
@@ -128,12 +128,12 @@ class ResetPasswordTests(EventTestMixin, CacheIsolationTestCase):
'email': 'thisdoesnotexist{0}@foo.com'.format(i)
})
good_resp = password_reset(good_req)
self.assertEquals(good_resp.status_code, 200)
self.assertEqual(good_resp.status_code, 200)
# then the rate limiter should kick in and give a HttpForbidden response
bad_req = self.request_factory.post('/password_reset/', {'email': 'thisdoesnotexist@foo.com'})
bad_resp = password_reset(bad_req)
self.assertEquals(bad_resp.status_code, 403)
self.assertEqual(bad_resp.status_code, 403)
self.assert_no_events_were_emitted()
cache.clear()
@@ -154,7 +154,7 @@ class ResetPasswordTests(EventTestMixin, CacheIsolationTestCase):
dot_access_token = dot_factories.AccessTokenFactory(user=self.user, application=dot_application)
dot_factories.RefreshTokenFactory(user=self.user, application=dot_application, access_token=dot_access_token)
good_resp = password_reset(good_req)
self.assertEquals(good_resp.status_code, 200)
self.assertEqual(good_resp.status_code, 200)
self.assertFalse(dop_models.AccessToken.objects.filter(user=self.user).exists())
self.assertFalse(dop_models.RefreshToken.objects.filter(user=self.user).exists())
self.assertFalse(dot_models.AccessToken.objects.filter(user=self.user).exists())
@@ -175,8 +175,8 @@ class ResetPasswordTests(EventTestMixin, CacheIsolationTestCase):
self.assertIn("Password reset", sent_message.subject)
self.assertIn(expected_output, body)
self.assertEquals(sent_message.from_email, from_email)
self.assertEquals(len(sent_message.to), 1)
self.assertEqual(sent_message.from_email, from_email)
self.assertEqual(len(sent_message.to), 1)
self.assertIn(self.user.email, sent_message.to)
self.assert_event_emitted(
@@ -463,7 +463,7 @@ class ResetPasswordTests(EventTestMixin, CacheIsolationTestCase):
good_reset_req.user = self.user
password_reset_confirm_wrapper(good_reset_req, self.uidb36, self.token)
confirm_kwargs = reset_confirm.call_args[1]
self.assertEquals(confirm_kwargs['extra_context']['platform_name'], 'Fake University')
self.assertEqual(confirm_kwargs['extra_context']['platform_name'], 'Fake University')
self.user = User.objects.get(pk=self.user.pk)
self.assertTrue(self.user.is_active)

8
openedx/core/djangoapps/util/tests/test_user_messages.py
View File

@@ -43,7 +43,7 @@ class UserMessagesTestCase(TestCase):
PageLevelMessages.register_user_message(self.request, UserMessageType.INFO, message)
messages = list(PageLevelMessages.user_messages(self.request))
self.assertEqual(len(messages), 1)
self.assertEquals(messages[0].message_html, expected_message_html)
self.assertEqual(messages[0].message_html, expected_message_html)
@ddt.data(
(UserMessageType.ERROR, 'alert-danger', 'fa fa-warning'),
@@ -59,8 +59,8 @@ class UserMessagesTestCase(TestCase):
PageLevelMessages.register_user_message(self.request, message_type, TEST_MESSAGE)
messages = list(PageLevelMessages.user_messages(self.request))
self.assertEqual(len(messages), 1)
self.assertEquals(messages[0].css_class, expected_css_class)
self.assertEquals(messages[0].icon_class, expected_icon_class)
self.assertEqual(messages[0].css_class, expected_css_class)
self.assertEqual(messages[0].icon_class, expected_icon_class)
@ddt.data(
(normalize_repr(PageLevelMessages.register_error_message), UserMessageType.ERROR),
@@ -76,4 +76,4 @@ class UserMessagesTestCase(TestCase):
register_message_function(self.request, TEST_MESSAGE)
messages = list(PageLevelMessages.user_messages(self.request))
self.assertEqual(len(messages), 1)
self.assertEquals(messages[0].type, expected_message_type)
self.assertEqual(messages[0].type, expected_message_type)

2
openedx/core/djangoapps/verified_track_content/tests/test_partition_scheme.py
View File

@@ -103,7 +103,7 @@ class EnrollmentTrackPartitionSchemeTest(SharedModuleStoreTestCase):
"""
Ensure that the scheme extension is correctly plugged in (via entry point in setup.py)
"""
self.assertEquals(UserPartition.get_scheme('enrollment_track'), EnrollmentTrackPartitionScheme)
self.assertEqual(UserPartition.get_scheme('enrollment_track'), EnrollmentTrackPartitionScheme)
def test_create_user_partition(self):
user_partition = UserPartition.get_scheme('enrollment_track').create_user_partition(

8
openedx/core/djangolib/tests/test_js_utils.py
View File

@@ -46,7 +46,7 @@ class TestJSUtils(TestCase):
)
escaped_json = dump_js_escaped_json(malicious_dict)
self.assertEquals(expected_escaped_json, escaped_json)
self.assertEqual(expected_escaped_json, escaped_json)
def test_dump_js_escaped_json_with_custom_encoder_escapes_unsafe_html(self):
"""
@@ -66,7 +66,7 @@ class TestJSUtils(TestCase):
)
escaped_json = dump_js_escaped_json(malicious_dict, cls=self.SampleJSONEncoder)
self.assertEquals(expected_custom_escaped_json, escaped_json)
self.assertEqual(expected_custom_escaped_json, escaped_json)
def test_js_escaped_string_escapes_unsafe_html(self):
"""
@@ -78,14 +78,14 @@ class TestJSUtils(TestCase):
r"\u003C/script\u003E\u003Cscript\u003Ealert(\u0027hello, \u0027)\u003B\u003C/script\u003E"
)
escaped_string_for_js = js_escaped_string(malicious_js_string)
self.assertEquals(expected_escaped_string_for_js, escaped_string_for_js)
self.assertEqual(expected_escaped_string_for_js, escaped_string_for_js)
def test_js_escaped_string_with_none(self):
"""
Test js_escaped_string returns empty string for None
"""
escaped_string_for_js = js_escaped_string(None)
self.assertEquals(u"", escaped_string_for_js)
self.assertEqual(u"", escaped_string_for_js)
def test_mako(self):
"""

4
openedx/core/lib/tests/test_courses.py
View File

@@ -24,7 +24,7 @@ class CourseImageTestCase(ModuleStoreTestCase):
"""
if not expected_url.startswith("/"):
expected_url = "/" + expected_url
self.assertEquals(expected_url, actual_url)
self.assertEqual(expected_url, actual_url)
def test_get_image_url(self):
"""Test image URL formatting."""
@@ -61,7 +61,7 @@ class CourseImageTestCase(ModuleStoreTestCase):
`DEFAULT_COURSE_ABOUT_IMAGE_URL` defined in the settings.
"""
course = CourseFactory.create(course_image='', default_store=default_store)
self.assertEquals(
self.assertEqual(
'static/test.png',
course_image_url(course),
)

2
openedx/core/lib/tests/test_url_utils.py
View File

@@ -27,7 +27,7 @@ class TestQuoteSlashes(TestCase):
@data(*TEST_STRINGS)
def test_inverse(self, test_string):
self.assertEquals(test_string, unquote_slashes(quote_slashes(test_string)))
self.assertEqual(test_string, unquote_slashes(quote_slashes(test_string)))
@data(*TEST_STRINGS)
def test_escaped(self, test_string):

4
openedx/features/announcements/tests/test_announcements.py
View File

@@ -66,12 +66,12 @@ class TestGlobalAnnouncements(TestCase):
url = reverse("announcements:page", kwargs={"page": 1})
response = self.client.get(url)
data = json.loads(response.content.decode('utf-8'))
self.assertEquals(data['num_pages'], 1)
self.assertEqual(data['num_pages'], 1)
## double the number of announcements to verify the number of pages increases
self.setUpTestData()
response = self.client.get(url)
data = json.loads(response.content.decode('utf-8'))
self.assertEquals(data['num_pages'], 2)
self.assertEqual(data['num_pages'], 2)
def test_active(self):
"""

6
openedx/features/content_type_gating/tests/test_access.py
View File

@@ -682,9 +682,9 @@ class TestProblemTypeAccess(SharedModuleStoreTestCase):
block_view_url = reverse('render_xblock', kwargs={'usage_key_string': six.text_type(block.scope_ids.usage_id)})
response = self.client.get(block_view_url)
if is_gated:
self.assertEquals(response.status_code, 404)
self.assertEqual(response.status_code, 404)
else:
self.assertEquals(response.status_code, 200)
self.assertEqual(response.status_code, 200)
def update_masquerade(self, role='student', group_id=None, username=None, user_partition_id=None):
"""
@@ -741,7 +741,7 @@ class TestProblemTypeAccess(SharedModuleStoreTestCase):
block = self.blocks_dict['problem']
block_view_url = reverse('render_xblock', kwargs={'usage_key_string': six.text_type(block.scope_ids.usage_id)})
response = self.client.get(block_view_url)
self.assertEquals(response.status_code, 200)
self.assertEqual(response.status_code, 200)
@ddt.data(
FORUM_ROLE_COMMUNITY_TA,

2
openedx/features/enterprise_support/tests/test_api.py
View File

@@ -341,7 +341,7 @@ class TestEnterpriseApi(EnterpriseServiceMockMixin, CacheIsolationTestCase):
# not be called.
if consent_required:
self.assertIsInstance(response, HttpResponseRedirect)
self.assertEquals(response.url, consent_url) # pylint: disable=no-member
self.assertEqual(response.url, consent_url) # pylint: disable=no-member
# Otherwise, the view function should have been called with the expected arguments.
else: