replaced unittest assertions pytest assertions (#26308)

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

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

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(

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/')