From 01ac3c2ed341afac5e0fc6535d993e19d8e50845 Mon Sep 17 00:00:00 2001 From: Aarif Date: Thu, 11 Feb 2021 17:41:41 +0500 Subject: [PATCH] replaced unittest assertions pytest assertions (#26308) --- lms/djangoapps/tests/test_utils.py | 2 +- .../waffle_utils/tests/test_init.py | 18 ++-- .../waffle_utils/tests/test_models.py | 4 +- .../waffle_utils/tests/test_views.py | 84 +++++++------------ 4 files changed, 44 insertions(+), 64 deletions(-) diff --git a/lms/djangoapps/tests/test_utils.py b/lms/djangoapps/tests/test_utils.py index 509028a98d..6781abc5d1 100644 --- a/lms/djangoapps/tests/test_utils.py +++ b/lms/djangoapps/tests/test_utils.py @@ -26,4 +26,4 @@ class UtilsTests(TestCase): # lint-amnesty, pylint: disable=missing-class-docst ) @ddt.unpack def test_get_key(self, input_key, output_key, key_cls): - self.assertEqual(_get_key(input_key, key_cls), output_key) + assert _get_key(input_key, key_cls) == output_key diff --git a/openedx/core/djangoapps/waffle_utils/tests/test_init.py b/openedx/core/djangoapps/waffle_utils/tests/test_init.py index c12a55539c..3a85d9676e 100644 --- a/openedx/core/djangoapps/waffle_utils/tests/test_init.py +++ b/openedx/core/djangoapps/waffle_utils/tests/test_init.py @@ -57,8 +57,8 @@ class TestCourseWaffleFlag(TestCase): with patch.object(WaffleFlagCourseOverrideModel, 'override_value', return_value=data['course_override']): with override_flag(self.NAMESPACED_FLAG_NAME, active=data['waffle_enabled']): # check twice to test that the result is properly cached - self.assertEqual(self.TEST_COURSE_FLAG.is_enabled(self.TEST_COURSE_KEY), data['result']) - self.assertEqual(self.TEST_COURSE_FLAG.is_enabled(self.TEST_COURSE_KEY), data['result']) + assert self.TEST_COURSE_FLAG.is_enabled(self.TEST_COURSE_KEY) == data['result'] + assert self.TEST_COURSE_FLAG.is_enabled(self.TEST_COURSE_KEY) == data['result'] # result is cached, so override check should happen once # pylint: disable=no-member WaffleFlagCourseOverrideModel.override_value.assert_called_once_with( @@ -71,12 +71,12 @@ class TestCourseWaffleFlag(TestCase): # When course override wasn't set for the first course, the second course will get the same # cached value from waffle. second_value = data['waffle_enabled'] - self.assertEqual(self.TEST_COURSE_FLAG.is_enabled(self.TEST_COURSE_2_KEY), second_value) + assert self.TEST_COURSE_FLAG.is_enabled(self.TEST_COURSE_2_KEY) == second_value else: # When course override was set for the first course, it should not apply to the second # course which should get the default value of False. second_value = False - self.assertEqual(self.TEST_COURSE_FLAG.is_enabled(self.TEST_COURSE_2_KEY), second_value) + assert self.TEST_COURSE_FLAG.is_enabled(self.TEST_COURSE_2_KEY) == second_value def test_undefined_waffle_flag(self): """ @@ -94,8 +94,8 @@ class TestCourseWaffleFlag(TestCase): return_value=WaffleFlagCourseOverrideModel.ALL_CHOICES.unset ): # check twice to test that the result is properly cached - self.assertEqual(test_course_flag.is_enabled(self.TEST_COURSE_KEY), False) - self.assertEqual(test_course_flag.is_enabled(self.TEST_COURSE_KEY), False) + assert test_course_flag.is_enabled(self.TEST_COURSE_KEY) is False + assert test_course_flag.is_enabled(self.TEST_COURSE_KEY) is False # result is cached, so override check should happen once # pylint: disable=no-member WaffleFlagCourseOverrideModel.override_value.assert_called_once_with( @@ -113,7 +113,7 @@ class TestCourseWaffleFlag(TestCase): self.FLAG_NAME, __name__, ) - self.assertEqual(test_course_flag.is_enabled(self.TEST_COURSE_KEY), False) + assert test_course_flag.is_enabled(self.TEST_COURSE_KEY) is False def test_without_request_and_everyone_active_waffle(self): """ @@ -126,7 +126,7 @@ class TestCourseWaffleFlag(TestCase): __name__, ) with override_flag(self.NAMESPACED_FLAG_NAME, active=True): - self.assertEqual(test_course_flag.is_enabled(self.TEST_COURSE_KEY), True) + assert test_course_flag.is_enabled(self.TEST_COURSE_KEY) is True class DeprecatedWaffleFlagTests(TestCase): @@ -137,4 +137,4 @@ class DeprecatedWaffleFlagTests(TestCase): def test_waffle_switch_namespace_override(self): namespace = WaffleSwitchNamespace("namespace") with namespace.override("waffle_switch1", True): - self.assertTrue(namespace.is_enabled("waffle_switch1")) + assert namespace.is_enabled('waffle_switch1') diff --git a/openedx/core/djangoapps/waffle_utils/tests/test_models.py b/openedx/core/djangoapps/waffle_utils/tests/test_models.py index 33919c3d0d..719ea6a900 100644 --- a/openedx/core/djangoapps/waffle_utils/tests/test_models.py +++ b/openedx/core/djangoapps/waffle_utils/tests/test_models.py @@ -31,7 +31,7 @@ class WaffleFlagCourseOverrideTests(TestCase): override_value = WaffleFlagCourseOverrideModel.override_value( self.WAFFLE_TEST_NAME, self.TEST_COURSE_KEY ) - self.assertEqual(override_value, expected_result) + assert override_value == expected_result def test_setting_override_multiple_times(self): RequestCache.clear_all_namespaces() @@ -40,7 +40,7 @@ class WaffleFlagCourseOverrideTests(TestCase): override_value = WaffleFlagCourseOverrideModel.override_value( self.WAFFLE_TEST_NAME, self.TEST_COURSE_KEY ) - self.assertEqual(override_value, self.OVERRIDE_CHOICES.off) + assert override_value == self.OVERRIDE_CHOICES.off def set_waffle_course_override(self, override_choice, is_enabled=True): WaffleFlagCourseOverrideModel.objects.create( diff --git a/openedx/core/djangoapps/waffle_utils/tests/test_views.py b/openedx/core/djangoapps/waffle_utils/tests/test_views.py index d5aed9ef14..726a509a39 100644 --- a/openedx/core/djangoapps/waffle_utils/tests/test_views.py +++ b/openedx/core/djangoapps/waffle_utils/tests/test_views.py @@ -25,55 +25,42 @@ class ToggleStateViewTests(TestCase): # lint-amnesty, pylint: disable=missing-c def test_success_for_staff(self): response = self._get_toggle_state_response() - self.assertEqual(response.status_code, 200) - self.assertTrue(response.data) + assert response.status_code == 200 + assert response.data def test_failure_for_non_staff(self): response = self._get_toggle_state_response(is_staff=False) - self.assertEqual(response.status_code, 403) + assert response.status_code == 403 @override_waffle_flag(TEST_WAFFLE_FLAG, True) def test_response_with_waffle_flag(self): response = self._get_toggle_state_response() - self.assertIn('waffle_flags', response.data) - self.assertTrue(response.data['waffle_flags']) + assert 'waffle_flags' in response.data + assert response.data['waffle_flags'] waffle_names = [waffle["name"] for waffle in response.data['waffle_flags']] - self.assertIn('test.flag', waffle_names) + assert 'test.flag' in waffle_names @override_switch('test.switch', True) def test_response_with_waffle_switch(self): response = self._get_toggle_state_response() - self.assertIn('waffle_switches', response.data) - self.assertTrue(response.data['waffle_switches']) + assert 'waffle_switches' in response.data + assert response.data['waffle_switches'] waffle_names = [waffle["name"] for waffle in response.data['waffle_switches']] - self.assertIn('test.switch', waffle_names) + assert 'test.switch' in waffle_names def test_response_with_setting_toggle(self): _toggle = SettingToggle("MYSETTING", default=False, module_name="module1") with override_settings(MYSETTING=True): response = self._get_toggle_state_response() - self.assertIn( - { - "name": "MYSETTING", - "is_active": True, - "module": "module1", - "class": "SettingToggle", - }, - response.data["django_settings"], - ) + assert {'name': 'MYSETTING', 'is_active': True, 'module': 'module1', 'class': 'SettingToggle'}\ + in response.data['django_settings'] def test_response_with_existing_setting_dict_toggle(self): response = self._get_toggle_state_response() - self.assertIn( - { - "name": "FEATURES['MILESTONES_APP']", - "is_active": True, - "module": "common.djangoapps.util.milestones_helpers", - "class": "SettingDictToggle", - }, - response.data["django_settings"], - ) + assert {'name': "FEATURES['MILESTONES_APP']", 'is_active': True, + 'module': 'common.djangoapps.util.milestones_helpers', + 'class': 'SettingDictToggle'} in response.data['django_settings'] def test_response_with_new_setting_dict_toggle(self): _toggle = SettingDictToggle( @@ -84,15 +71,8 @@ class ToggleStateViewTests(TestCase): # lint-amnesty, pylint: disable=missing-c setting_dict = {toggle["name"]: toggle for toggle in response.data["django_settings"]} - self.assertEqual( - { - "name": "CUSTOM_FEATURES['MYSETTING']", - "is_active": True, - "module": "module1", - "class": "SettingDictToggle", - }, - setting_dict["CUSTOM_FEATURES['MYSETTING']"], - ) + assert {'name': "CUSTOM_FEATURES['MYSETTING']", 'is_active': True, 'module': 'module1', + 'class': 'SettingDictToggle'} == setting_dict["CUSTOM_FEATURES['MYSETTING']"] def test_setting_overridden_by_setting_toggle(self): _toggle2 = SettingToggle( @@ -103,18 +83,18 @@ class ToggleStateViewTests(TestCase): # lint-amnesty, pylint: disable=missing-c ) with override_settings(MYSETTING1=True, MYSETTING2=False, MYDICT={"MYSETTING3": False}): # Need to pre-load settings, otherwise they are not picked up by the view - self.assertTrue(settings.MYSETTING1) + assert settings.MYSETTING1 response = self._get_toggle_state_response() setting_dict = {toggle["name"]: toggle for toggle in response.data["django_settings"]} # Check that Django settings for which a SettingToggle exists have both the correct is_active and class values - self.assertTrue(setting_dict["MYSETTING1"]["is_active"]) - self.assertNotIn("class", setting_dict["MYSETTING1"]) - self.assertFalse(setting_dict["MYSETTING2"]["is_active"]) - self.assertEqual("SettingToggle", setting_dict["MYSETTING2"]["class"]) - self.assertFalse(setting_dict["MYDICT['MYSETTING3']"]["is_active"]) - self.assertEqual("SettingDictToggle", setting_dict["MYDICT['MYSETTING3']"]["class"]) + assert setting_dict['MYSETTING1']['is_active'] + assert 'class' not in setting_dict['MYSETTING1'] + assert not setting_dict['MYSETTING2']['is_active'] + assert 'SettingToggle' == setting_dict['MYSETTING2']['class'] + assert not setting_dict["MYDICT['MYSETTING3']"]['is_active'] + assert 'SettingDictToggle' == setting_dict["MYDICT['MYSETTING3']"]['class'] def test_no_duplicate_setting_toggle(self): _toggle1 = SettingToggle( @@ -131,8 +111,8 @@ class ToggleStateViewTests(TestCase): # lint-amnesty, pylint: disable=missing-c response_toggles_2 = [ toggle for toggle in response.data["django_settings"] if toggle["name"] == "MYDICT['MYSETTING2']" ] - self.assertEqual(1, len(response_toggles_1)) - self.assertEqual(1, len(response_toggles_2)) + assert 1 == len(response_toggles_1) + assert 1 == len(response_toggles_2) def test_code_owners_without_module_information(self): # Create a waffle flag without any associated module_name @@ -142,7 +122,7 @@ class ToggleStateViewTests(TestCase): # lint-amnesty, pylint: disable=missing-c result = [ flag for flag in response.data["waffle_flags"] if flag["name"] == waffle_flag.name ][0] - self.assertNotIn("code_owner", result) + assert 'code_owner' not in result def test_course_overrides(self): models.WaffleFlagCourseOverrideModel.objects.create(waffle_flag="my.flag", enabled=True) @@ -152,12 +132,12 @@ class ToggleStateViewTests(TestCase): # lint-amnesty, pylint: disable=missing-c toggle_state_views._add_waffle_flag_course_override_state(course_overrides) toggle_state_views._add_waffle_flag_computed_status(course_overrides) - self.assertIn("my.flag", course_overrides) - self.assertIn("course_overrides", course_overrides["my.flag"]) - self.assertEqual(1, len(course_overrides["my.flag"]["course_overrides"])) - self.assertEqual("None", course_overrides["my.flag"]["course_overrides"][0]["course_id"]) - self.assertEqual("on", course_overrides["my.flag"]["course_overrides"][0]["force"]) - self.assertEqual("both", course_overrides["my.flag"]["computed_status"]) + assert 'my.flag' in course_overrides + assert 'course_overrides' in course_overrides['my.flag'] + assert 1 == len(course_overrides['my.flag']['course_overrides']) + assert 'None' == course_overrides['my.flag']['course_overrides'][0]['course_id'] + assert 'on' == course_overrides['my.flag']['course_overrides'][0]['force'] + assert 'both' == course_overrides['my.flag']['computed_status'] def _get_toggle_state_response(self, is_staff=True): # lint-amnesty, pylint: disable=missing-function-docstring request = APIRequestFactory().get('/api/toggles/state/')