replaced unittest assertions pytest assertions (#26568)

openedx/core/djangoapps/programs/tests/test_backpopulate_program_credentials.py

@@ -289,8 +289,8 @@ class BackpopulateProgramCredentialsTests(CatalogIntegrationMixin, CredentialsAp
         passing_status = CertificateStatuses.downloadable
         failing_status = CertificateStatuses.notpassing
 
-        self.assertIn(passing_status, CertificateStatuses.PASSED_STATUSES)
-        self.assertNotIn(failing_status, CertificateStatuses.PASSED_STATUSES)
+        assert passing_status in CertificateStatuses.PASSED_STATUSES
+        assert failing_status not in CertificateStatuses.PASSED_STATUSES
 
         GeneratedCertificateFactory(
             user=self.alice,
@@ -382,7 +382,7 @@ class BackpopulateProgramCredentialsTests(CatalogIntegrationMixin, CredentialsAp
 
         call_command('backpopulate_program_credentials', commit=True)
 
-        self.assertTrue(mock_log.called)
+        assert mock_log.called
 
         calls = [
             mock.call(self.alice.username),

openedx/core/djangoapps/programs/tests/test_signals.py

@@ -62,7 +62,7 @@ class CertAwardedReceiverTest(TestCase):
         known to take place inside the function.
         """
         COURSE_CERT_AWARDED.send(**self.signal_kwargs)
-        self.assertEqual(mock_is_learner_issuance_enabled.call_count, 1)
+        assert mock_is_learner_issuance_enabled.call_count == 1
 
     def test_programs_disabled(self, mock_is_learner_issuance_enabled, mock_task):
         """
@@ -70,8 +70,8 @@ class CertAwardedReceiverTest(TestCase):
         configuration is not enabled.
         """
         handle_course_cert_awarded(**self.signal_kwargs)
-        self.assertEqual(mock_is_learner_issuance_enabled.call_count, 1)
-        self.assertEqual(mock_task.call_count, 0)
+        assert mock_is_learner_issuance_enabled.call_count == 1
+        assert mock_task.call_count == 0
 
     def test_programs_enabled(self, mock_is_learner_issuance_enabled, mock_task):
         """
@@ -82,9 +82,9 @@ class CertAwardedReceiverTest(TestCase):
 
         handle_course_cert_awarded(**self.signal_kwargs)
 
-        self.assertEqual(mock_is_learner_issuance_enabled.call_count, 1)
-        self.assertEqual(mock_task.call_count, 1)
-        self.assertEqual(mock_task.call_args[0], (TEST_USERNAME,))
+        assert mock_is_learner_issuance_enabled.call_count == 1
+        assert mock_task.call_count == 1
+        assert mock_task.call_args[0] == (TEST_USERNAME,)
 
 
 # The credentials app isn't installed for the CMS.
@@ -127,7 +127,7 @@ class CertChangedReceiverTest(TestCase):
         known to take place inside the function.
         """
         COURSE_CERT_CHANGED.send(**self.signal_kwargs)
-        self.assertEqual(mock_is_learner_issuance_enabled.call_count, 2)
+        assert mock_is_learner_issuance_enabled.call_count == 2
 
     def test_credentials_disabled(self, mock_is_learner_issuance_enabled, mock_task):
         """
@@ -135,8 +135,8 @@ class CertChangedReceiverTest(TestCase):
         configuration is not enabled.
         """
         handle_course_cert_changed(**self.signal_kwargs)
-        self.assertEqual(mock_is_learner_issuance_enabled.call_count, 1)
-        self.assertEqual(mock_task.call_count, 0)
+        assert mock_is_learner_issuance_enabled.call_count == 1
+        assert mock_task.call_count == 0
 
     def test_credentials_enabled(self, mock_is_learner_issuance_enabled, mock_task):
         """
@@ -147,9 +147,9 @@ class CertChangedReceiverTest(TestCase):
 
         handle_course_cert_changed(**self.signal_kwargs)
 
-        self.assertEqual(mock_is_learner_issuance_enabled.call_count, 1)
-        self.assertEqual(mock_task.call_count, 1)
-        self.assertEqual(mock_task.call_args[0], (TEST_USERNAME, str(TEST_COURSE_KEY)))
+        assert mock_is_learner_issuance_enabled.call_count == 1
+        assert mock_task.call_count == 1
+        assert mock_task.call_args[0] == (TEST_USERNAME, str(TEST_COURSE_KEY))
 
     def test_records_enabled(self, mock_is_learner_issuance_enabled, mock_task):
         mock_is_learner_issuance_enabled.return_value = True
@@ -160,14 +160,14 @@ class CertChangedReceiverTest(TestCase):
 
         # Correctly sent
         handle_course_cert_changed(**self.signal_kwargs)
-        self.assertTrue(mock_task.called)
+        assert mock_task.called
         mock_task.reset_mock()
 
         # Correctly not sent
         site_config.site_values['ENABLE_LEARNER_RECORDS'] = False
         site_config.save()
         handle_course_cert_changed(**self.signal_kwargs)
-        self.assertFalse(mock_task.called)
+        assert not mock_task.called
 
 
 # The credentials app isn't installed for the CMS.
@@ -206,7 +206,7 @@ class CertRevokedReceiverTest(TestCase):
         known to take place inside the function.
         """
         COURSE_CERT_REVOKED.send(**self.signal_kwargs)
-        self.assertEqual(mock_is_learner_issuance_enabled.call_count, 1)
+        assert mock_is_learner_issuance_enabled.call_count == 1
 
     def test_programs_disabled(self, mock_is_learner_issuance_enabled, mock_task):
         """
@@ -214,8 +214,8 @@ class CertRevokedReceiverTest(TestCase):
         configuration is not enabled.
         """
         handle_course_cert_revoked(**self.signal_kwargs)
-        self.assertEqual(mock_is_learner_issuance_enabled.call_count, 1)
-        self.assertEqual(mock_task.call_count, 0)
+        assert mock_is_learner_issuance_enabled.call_count == 1
+        assert mock_task.call_count == 0
 
     def test_programs_enabled(self, mock_is_learner_issuance_enabled, mock_task):
         """
@@ -226,9 +226,9 @@ class CertRevokedReceiverTest(TestCase):
 
         handle_course_cert_revoked(**self.signal_kwargs)
 
-        self.assertEqual(mock_is_learner_issuance_enabled.call_count, 1)
-        self.assertEqual(mock_task.call_count, 1)
-        self.assertEqual(mock_task.call_args[0], (TEST_USERNAME, TEST_COURSE_KEY))
+        assert mock_is_learner_issuance_enabled.call_count == 1
+        assert mock_task.call_count == 1
+        assert mock_task.call_args[0] == (TEST_USERNAME, TEST_COURSE_KEY)
 
 
 @skip_unless_lms
@@ -263,7 +263,7 @@ class CourseCertAvailableDateChangedReceiverTest(TestCase):
         known to take place inside the function.
         """
         COURSE_CERT_DATE_CHANGE.send(**self.signal_kwargs)
-        self.assertEqual(mock_is_learner_issuance_enabled.call_count, 1)
+        assert mock_is_learner_issuance_enabled.call_count == 1
 
     def test_programs_disabled(self, mock_is_learner_issuance_enabled, mock_task):
         """
@@ -271,8 +271,8 @@ class CourseCertAvailableDateChangedReceiverTest(TestCase):
         configuration is not enabled.
         """
         handle_course_cert_date_change(**self.signal_kwargs)
-        self.assertEqual(mock_is_learner_issuance_enabled.call_count, 1)
-        self.assertEqual(mock_task.call_count, 0)
+        assert mock_is_learner_issuance_enabled.call_count == 1
+        assert mock_task.call_count == 0
 
     def test_programs_enabled(self, mock_is_learner_issuance_enabled, mock_task):
         """
@@ -283,5 +283,5 @@ class CourseCertAvailableDateChangedReceiverTest(TestCase):
 
         handle_course_cert_date_change(**self.signal_kwargs)
 
-        self.assertEqual(mock_is_learner_issuance_enabled.call_count, 1)
-        self.assertEqual(mock_task.call_count, 1)
+        assert mock_is_learner_issuance_enabled.call_count == 1
+        assert mock_task.call_count == 1

openedx/core/djangoapps/programs/tests/test_tasks.py

@@ -6,7 +6,7 @@ Tests for programs celery tasks.
 import json
 import logging
 from datetime import datetime, timedelta
-
+import pytest
 import ddt
 import httpretty
 import mock
@@ -70,9 +70,9 @@ class GetAwardedCertificateProgramsTestCase(TestCase):
         ]
 
         result = tasks.get_certified_programs(student)
-        self.assertEqual(mock_get_credentials.call_args[0], (student,))
-        self.assertEqual(mock_get_credentials.call_args[1], {'credential_type': 'program'})
-        self.assertEqual(result, [1])
+        assert mock_get_credentials.call_args[0] == (student,)
+        assert mock_get_credentials.call_args[1] == {'credential_type': 'program'}
+        assert result == [1]
 
 
 @skip_unless_lms
@@ -110,7 +110,7 @@ class AwardProgramCertificateTestCase(TestCase):
             ]
         }
         last_request_body = httpretty.last_request().body.decode('utf-8')
-        self.assertEqual(json.loads(last_request_body), expected_body)
+        assert json.loads(last_request_body) == expected_body
 
 
 @skip_unless_lms
@@ -171,10 +171,11 @@ class AwardProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiCo
         tasks.award_program_certificates.delay(self.student.username).get()
 
         actual_program_uuids = [call[0][2] for call in mock_award_program_certificate.call_args_list]
-        self.assertEqual(actual_program_uuids, expected_awarded_program_uuids)
+        assert actual_program_uuids == expected_awarded_program_uuids
 
         actual_visible_dates = [call[0][3] for call in mock_award_program_certificate.call_args_list]
-        self.assertEqual(actual_visible_dates, expected_awarded_program_uuids)  # program uuids are same as mock dates
+        assert actual_visible_dates == expected_awarded_program_uuids
+        # program uuids are same as mock dates
 
     @mock.patch('openedx.core.djangoapps.site_configuration.helpers.get_current_site_configuration')
     def test_awarding_certs_with_skip_program_certificate(
@@ -208,9 +209,10 @@ class AwardProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiCo
 
         tasks.award_program_certificates.delay(self.student.username).get()
         actual_program_uuids = [call[0][2] for call in mock_award_program_certificate.call_args_list]
-        self.assertEqual(actual_program_uuids, expected_awarded_program_uuids)
+        assert actual_program_uuids == expected_awarded_program_uuids
         actual_visible_dates = [call[0][3] for call in mock_award_program_certificate.call_args_list]
-        self.assertEqual(actual_visible_dates, expected_awarded_program_uuids)  # program uuids are same as mock dates
+        assert actual_visible_dates == expected_awarded_program_uuids
+        # program uuids are same as mock dates
 
     @ddt.data(
         ('credentials', 'enable_learner_issuance'),
@@ -228,11 +230,11 @@ class AwardProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiCo
         """
         getattr(self, 'create_{}_config'.format(disabled_config_type))(**{disabled_config_attribute: False})
         with mock.patch(TASKS_MODULE + '.LOGGER.warning') as mock_warning:
-            with self.assertRaises(MaxRetriesExceededError):
+            with pytest.raises(MaxRetriesExceededError):
                 tasks.award_program_certificates.delay(self.student.username).get()
-            self.assertTrue(mock_warning.called)
+            assert mock_warning.called
         for mock_helper in mock_helpers:
-            self.assertFalse(mock_helper.called)
+            assert not mock_helper.called
 
     def test_abort_if_invalid_username(self, *mock_helpers):
         """
@@ -241,9 +243,9 @@ class AwardProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiCo
         """
         with mock.patch(TASKS_MODULE + '.LOGGER.exception') as mock_exception:
             tasks.award_program_certificates.delay('nonexistent-username').get()
-            self.assertTrue(mock_exception.called)
+            assert mock_exception.called
         for mock_helper in mock_helpers:
-            self.assertFalse(mock_helper.called)
+            assert not mock_helper.called
 
     def test_abort_if_no_completed_programs(
         self,
@@ -257,9 +259,9 @@ class AwardProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiCo
         """
         mock_get_completed_programs.return_value = {}
         tasks.award_program_certificates.delay(self.student.username).get()
-        self.assertTrue(mock_get_completed_programs.called)
-        self.assertFalse(mock_get_certified_programs.called)
-        self.assertFalse(mock_award_program_certificate.called)
+        assert mock_get_completed_programs.called
+        assert not mock_get_certified_programs.called
+        assert not mock_award_program_certificate.called
 
     @mock.patch('openedx.core.djangoapps.site_configuration.helpers.get_value')
     def test_programs_without_certificates(
@@ -276,9 +278,9 @@ class AwardProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiCo
         mock_get_value.return_value = ["ALL"]
         mock_get_completed_programs.return_value = {1: 1, 2: 2}
         tasks.award_program_certificates.delay(self.student.username).get()
-        self.assertFalse(mock_get_completed_programs.called)
-        self.assertFalse(mock_get_certified_programs.called)
-        self.assertFalse(mock_award_program_certificate.called)
+        assert not mock_get_completed_programs.called
+        assert not mock_get_certified_programs.called
+        assert not mock_award_program_certificate.called
 
     @mock.patch(TASKS_MODULE + '.get_credentials_api_client')
     def test_failure_to_create_api_client_retries(
@@ -296,12 +298,12 @@ class AwardProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiCo
         mock_get_certified_programs.return_value = [2]
 
         with mock.patch(TASKS_MODULE + '.LOGGER.exception') as mock_exception:
-            with self.assertRaises(MaxRetriesExceededError):
+            with pytest.raises(MaxRetriesExceededError):
                 tasks.award_program_certificates.delay(self.student.username).get()
 
-        self.assertTrue(mock_exception.called)
-        self.assertEqual(mock_get_api_client.call_count, tasks.MAX_RETRIES + 1)
-        self.assertFalse(mock_award_program_certificate.called)
+        assert mock_exception.called
+        assert mock_get_api_client.call_count == (tasks.MAX_RETRIES + 1)
+        assert not mock_award_program_certificate.called
 
     def _make_side_effect(self, side_effects):
         """
@@ -344,7 +346,7 @@ class AwardProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiCo
                 mock.patch(TASKS_MODULE + '.LOGGER.warning') as mock_warning:
             tasks.award_program_certificates.delay(self.student.username).get()
 
-        self.assertEqual(mock_award_program_certificate.call_count, 3)
+        assert mock_award_program_certificate.call_count == 3
         mock_warning.assert_called_once_with(
             u'Failed to award certificate for program {uuid} to user {username}.'.format(
                 uuid=1,
@@ -366,7 +368,7 @@ class AwardProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiCo
         """
         mock_get_completed_programs.side_effect = self._make_side_effect([Exception('boom'), None])
         tasks.award_program_certificates.delay(self.student.username).get()
-        self.assertEqual(mock_get_completed_programs.call_count, 3)
+        assert mock_get_completed_programs.call_count == 3
 
     def test_retry_on_credentials_api_errors(
         self,
@@ -384,8 +386,8 @@ class AwardProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiCo
         mock_get_certified_programs.return_value = [1]
         mock_get_certified_programs.side_effect = self._make_side_effect([Exception('boom'), None])
         tasks.award_program_certificates.delay(self.student.username).get()
-        self.assertEqual(mock_get_certified_programs.call_count, 2)
-        self.assertEqual(mock_award_program_certificate.call_count, 1)
+        assert mock_get_certified_programs.call_count == 2
+        assert mock_award_program_certificate.call_count == 1
 
     def test_retry_on_credentials_api_429_error(
         self,
@@ -405,7 +407,7 @@ class AwardProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiCo
 
         tasks.award_program_certificates.delay(self.student.username).get()
 
-        self.assertEqual(mock_award_program_certificate.call_count, 3)
+        assert mock_award_program_certificate.call_count == 3
 
     def test_no_retry_on_credentials_api_404_error(
         self,
@@ -425,7 +427,7 @@ class AwardProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiCo
 
         tasks.award_program_certificates.delay(self.student.username).get()
 
-        self.assertEqual(mock_award_program_certificate.call_count, 2)
+        assert mock_award_program_certificate.call_count == 2
 
     def test_no_retry_on_credentials_api_4XX_error(
         self,
@@ -445,7 +447,7 @@ class AwardProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiCo
 
         tasks.award_program_certificates.delay(self.student.username).get()
 
-        self.assertEqual(mock_award_program_certificate.call_count, 2)
+        assert mock_award_program_certificate.call_count == 2
 
 
 @skip_unless_lms
@@ -496,7 +498,7 @@ class PostCourseCertificateTestCase(TestCase):
             }]
         }
         last_request_body = httpretty.last_request().body.decode('utf-8')
-        self.assertEqual(json.loads(last_request_body), expected_body)
+        assert json.loads(last_request_body) == expected_body
 
 
 @skip_unless_lms
@@ -544,9 +546,9 @@ class AwardCourseCertificatesTestCase(CredentialsApiConfigMixin, TestCase):
         self.certificate.save()
         tasks.award_course_certificate.delay(self.student.username, str(self.course.id)).get()
         call_args, _ = mock_post_course_certificate.call_args
-        self.assertEqual(call_args[1], self.student.username)
-        self.assertEqual(call_args[2], self.certificate)
-        self.assertEqual(call_args[3], self.certificate.modified_date)
+        assert call_args[1] == self.student.username
+        assert call_args[2] == self.certificate
+        assert call_args[3] == self.certificate.modified_date
 
     def test_award_course_certificates_available_date(self, mock_post_course_certificate):
         """
@@ -556,9 +558,9 @@ class AwardCourseCertificatesTestCase(CredentialsApiConfigMixin, TestCase):
         self.course.save()
         tasks.award_course_certificate.delay(self.student.username, str(self.course.id)).get()
         call_args, _ = mock_post_course_certificate.call_args
-        self.assertEqual(call_args[1], self.student.username)
-        self.assertEqual(call_args[2], self.certificate)
-        self.assertEqual(call_args[3], self.available_date)
+        assert call_args[1] == self.student.username
+        assert call_args[2] == self.certificate
+        assert call_args[3] == self.available_date
 
     def test_award_course_cert_not_called_if_disabled(self, mock_post_course_certificate):
         """
@@ -566,10 +568,10 @@ class AwardCourseCertificatesTestCase(CredentialsApiConfigMixin, TestCase):
         """
         self.create_credentials_config(enabled=False)
         with mock.patch(TASKS_MODULE + '.LOGGER.warning') as mock_warning:
-            with self.assertRaises(MaxRetriesExceededError):
+            with pytest.raises(MaxRetriesExceededError):
                 tasks.award_course_certificate.delay(self.student.username, str(self.course.id)).get()
-        self.assertTrue(mock_warning.called)
-        self.assertFalse(mock_post_course_certificate.called)
+        assert mock_warning.called
+        assert not mock_post_course_certificate.called
 
     def test_award_course_cert_not_called_if_user_not_found(self, mock_post_course_certificate):
         """
@@ -578,8 +580,8 @@ class AwardCourseCertificatesTestCase(CredentialsApiConfigMixin, TestCase):
         with mock.patch(TASKS_MODULE + '.LOGGER.exception') as mock_exception:
             # Use a random username here since this user won't be found in the DB
             tasks.award_course_certificate.delay('random_username', str(self.course.id)).get()
-        self.assertTrue(mock_exception.called)
-        self.assertFalse(mock_post_course_certificate.called)
+        assert mock_exception.called
+        assert not mock_post_course_certificate.called
 
     def test_award_course_cert_not_called_if_certificate_not_found(self, mock_post_course_certificate):
         """
@@ -588,8 +590,8 @@ class AwardCourseCertificatesTestCase(CredentialsApiConfigMixin, TestCase):
         self.certificate.delete()
         with mock.patch(TASKS_MODULE + '.LOGGER.exception') as mock_exception:
             tasks.award_course_certificate.delay(self.student.username, str(self.course.id)).get()
-        self.assertTrue(mock_exception.called)
-        self.assertFalse(mock_post_course_certificate.called)
+        assert mock_exception.called
+        assert not mock_post_course_certificate.called
 
     def test_award_course_cert_not_called_if_course_overview_not_found(self, mock_post_course_certificate):
         """
@@ -599,8 +601,8 @@ class AwardCourseCertificatesTestCase(CredentialsApiConfigMixin, TestCase):
         with mock.patch(TASKS_MODULE + '.LOGGER.exception') as mock_exception:
             # Use the certificate course id here since the course will be deleted
             tasks.award_course_certificate.delay(self.student.username, str(self.certificate.course_id)).get()
-        self.assertTrue(mock_exception.called)
-        self.assertFalse(mock_post_course_certificate.called)
+        assert mock_exception.called
+        assert not mock_post_course_certificate.called
 
     def test_award_course_cert_not_called_if_certificated_not_verified_mode(self, mock_post_course_certificate):
         """
@@ -613,7 +615,7 @@ class AwardCourseCertificatesTestCase(CredentialsApiConfigMixin, TestCase):
         self.create_credentials_config()
 
         tasks.award_course_certificate.delay(self.student.username, str(self.certificate.course_id)).get()
-        self.assertFalse(mock_post_course_certificate.called)
+        assert not mock_post_course_certificate.called
 
 
 @skip_unless_lms
@@ -646,7 +648,7 @@ class RevokeProgramCertificateTestCase(TestCase):
             }
         }
         last_request_body = httpretty.last_request().body.decode('utf-8')
-        self.assertEqual(json.loads(last_request_body), expected_body)
+        assert json.loads(last_request_body) == expected_body
 
 
 @skip_unless_lms
@@ -705,8 +707,8 @@ class RevokeProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiC
         tasks.revoke_program_certificates.delay(self.student.username, self.course_key).get()
 
         call_args, _ = mock_revoke_program_certificate.call_args
-        self.assertEqual(call_args[1], self.student.username)
-        self.assertEqual(call_args[2], expected_program_uuid)
+        assert call_args[1] == self.student.username
+        assert call_args[2] == expected_program_uuid
 
     @ddt.data(
         ('credentials', 'enable_learner_issuance'),
@@ -724,11 +726,11 @@ class RevokeProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiC
         """
         getattr(self, 'create_{}_config'.format(disabled_config_type))(**{disabled_config_attribute: False})
         with mock.patch(TASKS_MODULE + '.LOGGER.warning') as mock_warning:
-            with self.assertRaises(MaxRetriesExceededError):
+            with pytest.raises(MaxRetriesExceededError):
                 tasks.revoke_program_certificates.delay(self.student.username, self.course_key).get()
-            self.assertTrue(mock_warning.called)
+            assert mock_warning.called
         for mock_helper in mock_helpers:
-            self.assertFalse(mock_helper.called)
+            assert not mock_helper.called
 
     def test_abort_if_invalid_username(self, *mock_helpers):
         """
@@ -737,9 +739,9 @@ class RevokeProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiC
         """
         with mock.patch(TASKS_MODULE + '.LOGGER.exception') as mock_exception:
             tasks.revoke_program_certificates.delay('nonexistent-username', self.course_key).get()
-            self.assertTrue(mock_exception.called)
+            assert mock_exception.called
         for mock_helper in mock_helpers:
-            self.assertFalse(mock_helper.called)
+            assert not mock_helper.called
 
     def test_abort_if_no_program(
         self,
@@ -753,9 +755,9 @@ class RevokeProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiC
         """
         mock_get_inverted_programs.return_value = {}
         tasks.revoke_program_certificates.delay(self.student.username, self.course_key).get()
-        self.assertTrue(mock_get_inverted_programs.called)
-        self.assertFalse(mock_get_certified_programs.called)
-        self.assertFalse(mock_revoke_program_certificate.called)
+        assert mock_get_inverted_programs.called
+        assert not mock_get_certified_programs.called
+        assert not mock_revoke_program_certificate.called
 
     def _make_side_effect(self, side_effects):
         """
@@ -798,7 +800,7 @@ class RevokeProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiC
                 mock.patch(TASKS_MODULE + '.LOGGER.warning') as mock_warning:
             tasks.revoke_program_certificates.delay(self.student.username, self.course_key).get()
 
-        self.assertEqual(mock_revoke_program_certificate.call_count, 3)
+        assert mock_revoke_program_certificate.call_count == 3
         mock_warning.assert_called_once_with(
             u'Failed to revoke certificate for program {uuid} of user {username}.'.format(
                 uuid=1,
@@ -823,8 +825,8 @@ class RevokeProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiC
         mock_get_certified_programs.return_value = [1]
         mock_get_certified_programs.side_effect = self._make_side_effect([Exception('boom'), None])
         tasks.revoke_program_certificates.delay(self.student.username, self.course_key).get()
-        self.assertEqual(mock_get_certified_programs.call_count, 2)
-        self.assertEqual(mock_revoke_program_certificate.call_count, 1)
+        assert mock_get_certified_programs.call_count == 2
+        assert mock_revoke_program_certificate.call_count == 1
 
     def test_retry_on_credentials_api_429_error(
         self,
@@ -845,7 +847,7 @@ class RevokeProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiC
 
         tasks.revoke_program_certificates.delay(self.student.username, self.course_key).get()
 
-        self.assertEqual(mock_revoke_program_certificate.call_count, 3)
+        assert mock_revoke_program_certificate.call_count == 3
 
     def test_no_retry_on_credentials_api_404_error(
         self,
@@ -866,7 +868,7 @@ class RevokeProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiC
 
         tasks.revoke_program_certificates.delay(self.student.username, self.course_key).get()
 
-        self.assertEqual(mock_revoke_program_certificate.call_count, 2)
+        assert mock_revoke_program_certificate.call_count == 2
 
     def test_no_retry_on_credentials_api_4XX_error(
         self,
@@ -887,7 +889,7 @@ class RevokeProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiC
 
         tasks.revoke_program_certificates.delay(self.student.username, self.course_key).get()
 
-        self.assertEqual(mock_revoke_program_certificate.call_count, 2)
+        assert mock_revoke_program_certificate.call_count == 2
 
     def test_get_api_client_failure_retries(
         self,
@@ -907,8 +909,8 @@ class RevokeProgramCertificatesTestCase(CatalogIntegrationMixin, CredentialsApiC
             TASKS_MODULE + '.LOGGER.exception'
         ) as mock_exception:
             mock_get_api_client.side_effect = Exception("boom")
-            with self.assertRaises(MaxRetriesExceededError):
+            with pytest.raises(MaxRetriesExceededError):
                 tasks.revoke_program_certificates.delay(self.student.username, self.course_key).get()
-        self.assertTrue(mock_exception.called)
-        self.assertEqual(mock_get_api_client.call_count, tasks.MAX_RETRIES + 1)
-        self.assertFalse(mock_revoke_program_certificate.called)
+        assert mock_exception.called
+        assert mock_get_api_client.call_count == (tasks.MAX_RETRIES + 1)
+        assert not mock_revoke_program_certificate.called

openedx/core/djangoapps/programs/tests/test_utils.py

@@ -91,7 +91,7 @@ class TestProgramProgressMeter(TestCase):
 
     def _assert_progress(self, meter, *progresses):
         """Variadic helper used to verify progress calculations."""
-        self.assertEqual(meter.progress(), list(progresses))
+        assert meter.progress() == list(progresses)
 
     def _attach_detail_url(self, programs):
         """Add expected detail URLs to a list of program dicts."""
@@ -105,9 +105,9 @@ class TestProgramProgressMeter(TestCase):
 
         meter = ProgramProgressMeter(self.site, self.user)
 
-        self.assertEqual(meter.engaged_programs, [])
+        assert meter.engaged_programs == []
         self._assert_progress(meter)
-        self.assertEqual(list(meter.completed_programs_with_available_dates.keys()), [])
+        assert list(meter.completed_programs_with_available_dates.keys()) == []
 
     def test_enrollments_but_no_programs(self, mock_get_programs):
         """Verify behavior when enrollments exist, but no matching programs do."""
@@ -117,9 +117,9 @@ class TestProgramProgressMeter(TestCase):
         self._create_enrollments(course_run_id)
         meter = ProgramProgressMeter(self.site, self.user)
 
-        self.assertEqual(meter.engaged_programs, [])
+        assert meter.engaged_programs == []
         self._assert_progress(meter)
-        self.assertEqual(list(meter.completed_programs_with_available_dates.keys()), [])
+        assert list(meter.completed_programs_with_available_dates.keys()) == []
 
     def test_entitlements_but_no_programs(self, mock_get_programs):
         """ Verify engaged_programs is empty when entitlements exist, but no matching programs do. """
@@ -128,7 +128,7 @@ class TestProgramProgressMeter(TestCase):
         self._create_entitlements(uuid.uuid4())
         meter = ProgramProgressMeter(self.site, self.user)
 
-        self.assertEqual(meter.engaged_programs, [])
+        assert meter.engaged_programs == []
 
     def test_single_program_enrollment(self, mock_get_programs):
         """
@@ -153,12 +153,12 @@ class TestProgramProgressMeter(TestCase):
 
         self._attach_detail_url(data)
         program = data[0]
-        self.assertEqual(meter.engaged_programs, [program])
+        assert meter.engaged_programs == [program]
         self._assert_progress(
             meter,
             ProgressFactory(uuid=program['uuid'], in_progress=1)
         )
-        self.assertEqual(list(meter.completed_programs_with_available_dates.keys()), [])
+        assert list(meter.completed_programs_with_available_dates.keys()) == []
 
     def test_single_program_entitlement(self, mock_get_programs):
         """
@@ -177,7 +177,7 @@ class TestProgramProgressMeter(TestCase):
 
         self._attach_detail_url(data)
         program = data[0]
-        self.assertEqual(meter.engaged_programs, [program])
+        assert meter.engaged_programs == [program]
 
     def test_single_program_multiple_entitlements(self, mock_get_programs):
         """
@@ -221,11 +221,11 @@ class TestProgramProgressMeter(TestCase):
 
         meter = ProgramProgressMeter(self.site, self.user)
         self._attach_detail_url(data)
-        self.assertEqual(len(meter.entitlements), 1)
+        assert len(meter.entitlements) == 1
 
         entitlement = meter.entitlements[0]
-        self.assertIsNone(entitlement.expired_at)
-        self.assertEqual(entitlement.enrollment_course_run.course_id, enrollment2.course_id)
+        assert entitlement.expired_at is None
+        assert entitlement.enrollment_course_run.course_id == enrollment2.course_id
 
     def test_course_progress(self, mock_get_programs):
         """
@@ -258,7 +258,7 @@ class TestProgramProgressMeter(TestCase):
             )
         ]
 
-        self.assertEqual(meter.progress(count_only=False), expected)
+        assert meter.progress(count_only=False) == expected
 
     def test_no_id_professional_in_progress(self, mock_get_programs):
         """
@@ -294,7 +294,7 @@ class TestProgramProgressMeter(TestCase):
             )
         ]
 
-        self.assertEqual(meter.progress(count_only=False), expected)
+        assert meter.progress(count_only=False) == expected
 
     @ddt.data(None, 1, -1)
     def test_in_progress_course_upgrade_deadline_check(self, offset, mock_get_programs):
@@ -335,7 +335,7 @@ class TestProgramProgressMeter(TestCase):
             )
         ]
 
-        self.assertEqual(meter.progress(count_only=True), expected)
+        assert meter.progress(count_only=True) == expected
 
     def test_multiple_program_enrollment(self, mock_get_programs):
         """
@@ -369,13 +369,13 @@ class TestProgramProgressMeter(TestCase):
 
         self._attach_detail_url(data)
         programs = data[:2]
-        self.assertEqual(meter.engaged_programs, programs)
+        assert meter.engaged_programs == programs
 
         self._assert_progress(
             meter,
             *(ProgressFactory(uuid=program['uuid'], in_progress=1) for program in programs)
         )
-        self.assertEqual(list(meter.completed_programs_with_available_dates.keys()), [])
+        assert list(meter.completed_programs_with_available_dates.keys()) == []
 
     def test_multiple_program_entitlement(self, mock_get_programs):
         """
@@ -397,7 +397,7 @@ class TestProgramProgressMeter(TestCase):
 
         self._attach_detail_url(data)
         programs = data[:2]
-        self.assertEqual(meter.engaged_programs, programs)
+        assert meter.engaged_programs == programs
 
     def test_shared_enrollment_engagement(self, mock_get_programs):
         """
@@ -437,13 +437,13 @@ class TestProgramProgressMeter(TestCase):
 
         self._attach_detail_url(data)
         programs = data[:3]
-        self.assertEqual(meter.engaged_programs, programs)
+        assert meter.engaged_programs == programs
 
         self._assert_progress(
             meter,
             *(ProgressFactory(uuid=program['uuid'], in_progress=1) for program in programs)
         )
-        self.assertEqual(list(meter.completed_programs_with_available_dates.keys()), [])
+        assert list(meter.completed_programs_with_available_dates.keys()) == []
 
     def test_shared_entitlement_engagement(self, mock_get_programs):
         """
@@ -471,7 +471,7 @@ class TestProgramProgressMeter(TestCase):
 
         self._attach_detail_url(data)
         programs = data[:3]
-        self.assertEqual(meter.engaged_programs, programs)
+        assert meter.engaged_programs == programs
 
     def test_simulate_progress(self, mock_get_programs):
         """Simulate the entirety of a user's progress through a program."""
@@ -494,7 +494,7 @@ class TestProgramProgressMeter(TestCase):
         # No enrollments, no programs in progress.
         meter = ProgramProgressMeter(self.site, self.user)
         self._assert_progress(meter)
-        self.assertEqual(list(meter.completed_programs_with_available_dates.keys()), [])
+        assert list(meter.completed_programs_with_available_dates.keys()) == []
 
         # One enrollment, one program in progress.
         self._create_enrollments(first_course_run_key)
@@ -504,7 +504,7 @@ class TestProgramProgressMeter(TestCase):
             meter,
             ProgressFactory(uuid=program_uuid, in_progress=1, not_started=1)
         )
-        self.assertEqual(list(meter.completed_programs_with_available_dates.keys()), [])
+        assert list(meter.completed_programs_with_available_dates.keys()) == []
 
         # Two enrollments, all courses in progress.
         self._create_enrollments(second_course_run_key)
@@ -516,7 +516,7 @@ class TestProgramProgressMeter(TestCase):
                 in_progress=2,
             )
         )
-        self.assertEqual(list(meter.completed_programs_with_available_dates.keys()), [])
+        assert list(meter.completed_programs_with_available_dates.keys()) == []
 
         # One valid certificate earned, one course complete.
         self._create_certificates(first_course_run_key, mode=MODES.verified)
@@ -529,7 +529,7 @@ class TestProgramProgressMeter(TestCase):
                 in_progress=1,
             )
         )
-        self.assertEqual(list(meter.completed_programs_with_available_dates.keys()), [])
+        assert list(meter.completed_programs_with_available_dates.keys()) == []
 
         # Invalid certificate earned, still one course to complete. (invalid because mode doesn't match the course)
         second_cert = self._create_certificates(second_course_run_key, mode=MODES.honor)[0]
@@ -543,7 +543,7 @@ class TestProgramProgressMeter(TestCase):
                 in_progress=1,
             )
         )
-        self.assertEqual(list(meter.completed_programs_with_available_dates.keys()), [])
+        assert list(meter.completed_programs_with_available_dates.keys()) == []
 
         # Second valid certificate obtained, all courses complete.
         second_cert.mode = MODES.verified
@@ -556,7 +556,7 @@ class TestProgramProgressMeter(TestCase):
                 completed=2,
             )
         )
-        self.assertEqual(list(meter.completed_programs_with_available_dates.keys()), [program_uuid])
+        assert list(meter.completed_programs_with_available_dates.keys()) == [program_uuid]
 
     def test_nonverified_course_run_completion(self, mock_get_programs):
         """
@@ -586,7 +586,7 @@ class TestProgramProgressMeter(TestCase):
             meter,
             ProgressFactory(uuid=program_uuid, completed=1)
         )
-        self.assertEqual(list(meter.completed_programs_with_available_dates.keys()), [program_uuid])
+        assert list(meter.completed_programs_with_available_dates.keys()) == [program_uuid]
 
     @mock.patch(UTILS_MODULE + '.available_date_for_certificate')
     def test_completed_programs_with_available_dates(self, mock_available_date_for_certificate, mock_get_programs):
@@ -674,7 +674,7 @@ class TestProgramProgressMeter(TestCase):
 
         # Verify that the test program is not complete.
         meter = ProgramProgressMeter(self.site, self.user)
-        self.assertEqual(list(meter.completed_programs_with_available_dates.keys()), [])
+        assert list(meter.completed_programs_with_available_dates.keys()) == []
 
         # Grant a 'no-id-professional' certificate for one of the course runs,
         # thereby completing the program.
@@ -683,7 +683,7 @@ class TestProgramProgressMeter(TestCase):
 
         # Verify that the program is complete.
         meter = ProgramProgressMeter(self.site, self.user)
-        self.assertEqual(list(meter.completed_programs_with_available_dates.keys()), [program['uuid']])
+        assert list(meter.completed_programs_with_available_dates.keys()) == [program['uuid']]
 
     @mock.patch(UTILS_MODULE + '.ProgramProgressMeter.completed_course_runs', new_callable=mock.PropertyMock)
     def test_credit_course_counted_complete_for_verified(self, mock_completed_course_runs, mock_get_programs):
@@ -700,7 +700,7 @@ class TestProgramProgressMeter(TestCase):
         self._create_enrollments(course_run_key)
         meter = ProgramProgressMeter(self.site, self.user)
         mock_completed_course_runs.return_value = [{'course_run_id': course_run_key, 'type': CourseMode.VERIFIED}]
-        self.assertEqual(meter._is_course_complete(course), True)  # lint-amnesty, pylint: disable=protected-access
+        assert meter._is_course_complete(course) is True  # lint-amnesty, pylint: disable=protected-access
 
     def test_detail_url_for_mobile_only(self, mock_get_programs):
         """
@@ -727,7 +727,7 @@ class TestProgramProgressMeter(TestCase):
         path_id = detail_fragment_url.replace('/dashboard/', '')
         expected_url = 'edxapp://enrolled_program_info?path_id={}'.format(path_id)
 
-        self.assertEqual(program_data['detail_url'], expected_url)
+        assert program_data['detail_url'] == expected_url
 
 
 def _create_course(self, course_price, course_run_count=1, make_entitlement=False):
@@ -812,7 +812,7 @@ class TestProgramDataExtender(ModuleStoreTestCase):
         course['course_runs'] = [course_run]
         program['courses'] = [course]
 
-        self.assertEqual(actual, program)
+        assert actual == program
 
     @ddt.data(-1, 0, 1)
     def test_is_enrollment_open(self, days_offset):
@@ -960,7 +960,7 @@ class TestProgramDataExtender(ModuleStoreTestCase):
 
         data = ProgramDataExtender(self.program, self.user).extend()
 
-        self.assertEqual(may_certify, data['courses'][0]['course_runs'][0]['may_certify'])
+        assert may_certify == data['courses'][0]['course_runs'][0]['may_certify']
 
         self._assert_supplemented(data)
 
@@ -971,7 +971,7 @@ class TestProgramDataExtender(ModuleStoreTestCase):
             - There are courses remaining that have not been purchased and enrolled in.
         """
         data = ProgramDataExtender(self.program, self.user).extend()
-        self.assertFalse(data['is_learner_eligible_for_one_click_purchase'])
+        assert not data['is_learner_eligible_for_one_click_purchase']
 
         courses = [_create_course(self, self.course_price)]
 
@@ -980,7 +980,7 @@ class TestProgramDataExtender(ModuleStoreTestCase):
             is_program_eligible_for_one_click_purchase=False
         )
         data = ProgramDataExtender(program, self.user).extend()
-        self.assertFalse(data['is_learner_eligible_for_one_click_purchase'])
+        assert not data['is_learner_eligible_for_one_click_purchase']
 
         course1 = _create_course(self, self.course_price)
         course2 = _create_course(self, self.course_price)
@@ -992,7 +992,7 @@ class TestProgramDataExtender(ModuleStoreTestCase):
             applicable_seat_types=[CourseMode.VERIFIED],
         )
         data = ProgramDataExtender(program2, self.user).extend()
-        self.assertTrue(data['is_learner_eligible_for_one_click_purchase'])
+        assert data['is_learner_eligible_for_one_click_purchase']
 
     def test_learner_eligibility_for_one_click_purchase_with_unpublished(self):
         """
@@ -1010,8 +1010,8 @@ class TestProgramDataExtender(ModuleStoreTestCase):
             applicable_seat_types=[CourseMode.VERIFIED],
         )
         data = ProgramDataExtender(program2, self.user).extend()
-        self.assertEqual(len(data['skus']), 1)
-        self.assertTrue(data['is_learner_eligible_for_one_click_purchase'])
+        assert len(data['skus']) == 1
+        assert data['is_learner_eligible_for_one_click_purchase']
 
     def test_learner_eligibility_for_one_click_purchase_professional_no_id(self):
         """
@@ -1029,7 +1029,7 @@ class TestProgramDataExtender(ModuleStoreTestCase):
             applicable_seat_types=[CourseMode.PROFESSIONAL]
         )
         data = ProgramDataExtender(program2, self.user).extend()
-        self.assertFalse(data['is_learner_eligible_for_one_click_purchase'])
+        assert not data['is_learner_eligible_for_one_click_purchase']
 
     def test_multiple_published_course_runs(self):
         """
@@ -1066,12 +1066,12 @@ class TestProgramDataExtender(ModuleStoreTestCase):
         )
         data = ProgramDataExtender(program, self.user).extend()
 
-        self.assertFalse(data['is_learner_eligible_for_one_click_purchase'])
+        assert not data['is_learner_eligible_for_one_click_purchase']
 
         course_run_2['status'] = 'unpublished'
         data = ProgramDataExtender(program, self.user).extend()
 
-        self.assertTrue(data['is_learner_eligible_for_one_click_purchase'])
+        assert data['is_learner_eligible_for_one_click_purchase']
 
     def test_learner_eligibility_for_one_click_purchase_entitlement_products(self):
         """
@@ -1088,8 +1088,8 @@ class TestProgramDataExtender(ModuleStoreTestCase):
             applicable_seat_types=[CourseMode.VERIFIED],
         )
         data = ProgramDataExtender(program, self.user).extend()
-        self.assertTrue(data['is_learner_eligible_for_one_click_purchase'])
-        self.assertEqual(set(data['skus']), expected_skus)
+        assert data['is_learner_eligible_for_one_click_purchase']
+        assert set(data['skus']) == expected_skus
 
     def test_learner_eligibility_for_one_click_purchase_ineligible_program(self):
         """
@@ -1103,8 +1103,8 @@ class TestProgramDataExtender(ModuleStoreTestCase):
             applicable_seat_types=[CourseMode.VERIFIED],
         )
         data = ProgramDataExtender(program, self.user).extend()
-        self.assertFalse(data['is_learner_eligible_for_one_click_purchase'])
-        self.assertEqual(data['skus'], [])
+        assert not data['is_learner_eligible_for_one_click_purchase']
+        assert data['skus'] == []
 
     def test_learner_eligibility_for_one_click_purchase_user_entitlements(self):
         """
@@ -1121,8 +1121,8 @@ class TestProgramDataExtender(ModuleStoreTestCase):
             applicable_seat_types=[CourseMode.VERIFIED],
         )
         data = ProgramDataExtender(program, self.user).extend()
-        self.assertTrue(data['is_learner_eligible_for_one_click_purchase'])
-        self.assertEqual(set(data['skus']), expected_skus)
+        assert data['is_learner_eligible_for_one_click_purchase']
+        assert set(data['skus']) == expected_skus
 
     def test_all_courses_owned(self):
         """
@@ -1139,8 +1139,8 @@ class TestProgramDataExtender(ModuleStoreTestCase):
         )
         data = ProgramDataExtender(program, self.user).extend()
 
-        self.assertFalse(data['is_learner_eligible_for_one_click_purchase'])
-        self.assertEqual(data['skus'], [])
+        assert not data['is_learner_eligible_for_one_click_purchase']
+        assert data['skus'] == []
 
     def test_old_course_runs(self):
         """
@@ -1172,8 +1172,8 @@ class TestProgramDataExtender(ModuleStoreTestCase):
             applicable_seat_types=[CourseMode.VERIFIED],
         )
         data = ProgramDataExtender(program, self.user).extend()
-        self.assertFalse(data['is_learner_eligible_for_one_click_purchase'])
-        self.assertEqual(data['skus'], [])
+        assert not data['is_learner_eligible_for_one_click_purchase']
+        assert data['skus'] == []
 
     def test_second_entitlement_product_wrong_mode(self):
         """
@@ -1192,8 +1192,8 @@ class TestProgramDataExtender(ModuleStoreTestCase):
             applicable_seat_types=[CourseMode.VERIFIED],
         )
         data = ProgramDataExtender(program, self.user).extend()
-        self.assertTrue(data['is_learner_eligible_for_one_click_purchase'])
-        self.assertEqual(set(data['skus']), expected_skus)
+        assert data['is_learner_eligible_for_one_click_purchase']
+        assert set(data['skus']) == expected_skus
 
     def test_entitlement_product_and_user_enrollment(self):
         """
@@ -1210,8 +1210,8 @@ class TestProgramDataExtender(ModuleStoreTestCase):
             applicable_seat_types=[CourseMode.VERIFIED],
         )
         data = ProgramDataExtender(program, self.user).extend()
-        self.assertTrue(data['is_learner_eligible_for_one_click_purchase'])
-        self.assertEqual(set(data['skus']), expected_skus)
+        assert data['is_learner_eligible_for_one_click_purchase']
+        assert set(data['skus']) == expected_skus
 
     def test_user_enrollment_with_other_course_entitlement_product(self):
         """
@@ -1228,8 +1228,8 @@ class TestProgramDataExtender(ModuleStoreTestCase):
             applicable_seat_types=[CourseMode.VERIFIED, CourseMode.PROFESSIONAL],
         )
         data = ProgramDataExtender(program, self.user).extend()
-        self.assertTrue(data['is_learner_eligible_for_one_click_purchase'])
-        self.assertEqual(set(data['skus']), expected_skus)
+        assert data['is_learner_eligible_for_one_click_purchase']
+        assert set(data['skus']) == expected_skus
 
     def test_course_url_with_mobile_only(self):
         """
@@ -1293,7 +1293,7 @@ class TestGetCertificates(TestCase):
         }]
 
         certificates = get_certificates(self.user, self.program)
-        self.assertEqual(certificates, expected)
+        assert certificates == expected
 
     def test_course_run_certificates_missing(self, mock_get_credentials):
         """
@@ -1317,8 +1317,8 @@ class TestGetCertificates(TestCase):
         mock_get_credentials.return_value = [{'certificate_url': self.program_certificate_url}]
 
         certificates = get_certificates(self.user, self.program)
-        self.assertTrue(mock_get_credentials.called)
-        self.assertEqual(certificates, expected)
+        assert mock_get_credentials.called
+        assert certificates == expected
 
     def test_program_certificate_missing(self, mock_get_credentials):
         """
@@ -1335,7 +1335,7 @@ class TestGetCertificates(TestCase):
         mock_get_credentials.return_value = []
 
         certificates = get_certificates(self.user, self.program)
-        self.assertEqual(certificates, expected)
+        assert certificates == expected
 
     def test_get_program_certificate_url(self, mock_get_credentials):  # pylint: disable=unused-argument
         """
@@ -1343,7 +1343,7 @@ class TestGetCertificates(TestCase):
         """
         expected = 'http://fake-credentials.edx.org/login/?next=/credentials/fake-uuid/'
         actual = get_logged_in_program_certificate_url(self.program_certificate_url)
-        self.assertEqual(expected, actual)
+        assert expected == actual
 
 
 @ddt.ddt
@@ -1408,15 +1408,15 @@ class TestProgramMarketingDataExtender(ModuleStoreTestCase):
         data = ProgramMarketingDataExtender(self.program, self.user).extend()
 
         self.program.update(self.instructors['instructors'])  # lint-amnesty, pylint: disable=no-member
-        self.assertEqual(data, self.program)
+        assert data == self.program
 
     def test_course_pricing(self):
         data = ProgramMarketingDataExtender(self.program, self.user).extend()
 
         program_full_price = self.course_price * self.number_of_courses
-        self.assertEqual(data['number_of_courses'], self.number_of_courses)
-        self.assertEqual(data['full_program_price'], program_full_price)
-        self.assertEqual(data['avg_price_per_course'], program_full_price / self.number_of_courses)
+        assert data['number_of_courses'] == self.number_of_courses
+        assert data['full_program_price'] == program_full_price
+        assert data['avg_price_per_course'] == (program_full_price / self.number_of_courses)
 
     def test_course_pricing_when_all_course_runs_have_no_seats(self):
         # Create three seatless course runs and add them to the program
@@ -1429,9 +1429,9 @@ class TestProgramMarketingDataExtender(ModuleStoreTestCase):
 
         data = ProgramMarketingDataExtender(program, self.user).extend()
 
-        self.assertEqual(data['number_of_courses'], len(program['courses']))
-        self.assertEqual(data['full_program_price'], 0.0)
-        self.assertEqual(data['avg_price_per_course'], 0.0)
+        assert data['number_of_courses'] == len(program['courses'])
+        assert data['full_program_price'] == 0.0
+        assert data['avg_price_per_course'] == 0.0
 
     @ddt.data(True, False)
     @mock.patch('django.contrib.auth.models.PermissionsMixin.has_perm')
@@ -1443,7 +1443,7 @@ class TestProgramMarketingDataExtender(ModuleStoreTestCase):
 
         data = ProgramMarketingDataExtender(self.program, self.user).extend()
 
-        self.assertEqual(data['courses'][0]['course_runs'][0]['can_enroll'], can_enroll)
+        assert data['courses'][0]['course_runs'][0]['can_enroll'] == can_enroll
 
     @httpretty.activate
     def test_fetching_program_discounted_price(self):
@@ -1468,12 +1468,9 @@ class TestProgramMarketingDataExtender(ModuleStoreTestCase):
         data = ProgramMarketingDataExtender(self.program, self.user).extend()
         self._update_discount_data(mock_discount_data)
 
-        self.assertEqual(httpretty.last_request().querystring.get('username')[0], self.user.username)  # lint-amnesty, pylint: disable=no-member
-        self.assertEqual(
-            data['skus'],
-            [course['course_runs'][0]['seats'][0]['sku'] for course in self.program['courses']]
-        )
-        self.assertEqual(data['discount_data'], mock_discount_data)
+        assert httpretty.last_request().querystring.get('username')[0] == self.user.username  # lint-amnesty, pylint: disable=no-member, line-too-long
+        assert data['skus'] == [course['course_runs'][0]['seats'][0]['sku'] for course in self.program['courses']]
+        assert data['discount_data'] == mock_discount_data
 
     @httpretty.activate
     @override_switch(ALWAYS_CALCULATE_PROGRAM_PRICE_AS_ANONYMOUS_USER.name, active=True)
@@ -1495,7 +1492,7 @@ class TestProgramMarketingDataExtender(ModuleStoreTestCase):
             content_type='application/json'
         )
         ProgramMarketingDataExtender(self.program, self.user).extend()
-        self.assertEqual(httpretty.last_request().querystring.get('is_anonymous')[0], u'True')  # lint-amnesty, pylint: disable=no-member
+        assert httpretty.last_request().querystring.get('is_anonymous')[0] == u'True'  # lint-amnesty, pylint: disable=no-member, line-too-long
 
     @httpretty.activate
     def test_fetching_program_discounted_price_as_anonymous_user(self):
@@ -1520,12 +1517,9 @@ class TestProgramMarketingDataExtender(ModuleStoreTestCase):
         data = ProgramMarketingDataExtender(self.program, user).extend()
         self._update_discount_data(mock_discount_data)
 
-        self.assertIsNotNone(httpretty.last_request().querystring.get('is_anonymous', None))  # lint-amnesty, pylint: disable=no-member
-        self.assertEqual(
-            data['skus'],
-            [course['course_runs'][0]['seats'][0]['sku'] for course in self.program['courses']]
-        )
-        self.assertEqual(data['discount_data'], mock_discount_data)
+        assert httpretty.last_request().querystring.get('is_anonymous', None) is not None  # lint-amnesty, pylint: disable=no-member, line-too-long
+        assert data['skus'] == [course['course_runs'][0]['seats'][0]['sku'] for course in self.program['courses']]
+        assert data['discount_data'] == mock_discount_data
 
     def test_fetching_program_discounted_price_no_applicable_seats(self):
         """
@@ -1534,7 +1528,7 @@ class TestProgramMarketingDataExtender(ModuleStoreTestCase):
         self.program['applicable_seat_types'] = []
         data = ProgramMarketingDataExtender(self.program, self.user).extend()
 
-        self.assertEqual(len(data['skus']), 0)
+        assert len(data['skus']) == 0
 
     @httpretty.activate
     def test_fetching_program_discounted_price_api_exception_caught(self):
@@ -1552,10 +1546,7 @@ class TestProgramMarketingDataExtender(ModuleStoreTestCase):
 
         data = ProgramMarketingDataExtender(self.program, self.user).extend()
 
-        self.assertEqual(
-            data['skus'],
-            [course['course_runs'][0]['seats'][0]['sku'] for course in self.program['courses']]
-        )
+        assert data['skus'] == [course['course_runs'][0]['seats'][0]['sku'] for course in self.program['courses']]
 
 
 @skip_unless_lms
@@ -1587,28 +1578,29 @@ class TestProgramEnrollment(SharedModuleStoreTestCase):
 
     def test_user_not_in_program(self, mock_get_programs_by_type):
         mock_get_programs_by_type.return_value = [self.program]
-        self.assertFalse(is_user_enrolled_in_program_type(user=self.user, program_type_slug=self.MICROBACHELORS))
+        assert not is_user_enrolled_in_program_type(user=self.user, program_type_slug=self.MICROBACHELORS)
 
     def test_user_enrolled_in_mb_program(self, mock_get_programs_by_type):
         CourseEnrollmentFactory.create(user=self.user, course_id=self.course_run.id, mode=CourseMode.VERIFIED)
         mock_get_programs_by_type.return_value = [self.program]
-        self.assertTrue(is_user_enrolled_in_program_type(user=self.user, program_type_slug=self.MICROBACHELORS))
+        assert is_user_enrolled_in_program_type(user=self.user, program_type_slug=self.MICROBACHELORS)
 
     def test_user_enrolled_unpaid_in_program(self, mock_get_programs_by_type):
         CourseEnrollmentFactory.create(user=self.user, course_id=self.course_run.id, mode=CourseMode.AUDIT)
         mock_get_programs_by_type.return_value = [self.program]
-        self.assertTrue(is_user_enrolled_in_program_type(user=self.user, program_type_slug=self.MICROBACHELORS))
+        assert is_user_enrolled_in_program_type(user=self.user, program_type_slug=self.MICROBACHELORS)
 
     def test_user_enrolled_unpaid_in_program_paid_only_request(self, mock_get_programs_by_type):
         CourseEnrollmentFactory.create(user=self.user, course_id=self.course_run.id, mode=CourseMode.AUDIT)
         mock_get_programs_by_type.return_value = [self.program]
-        self.assertFalse(
-            is_user_enrolled_in_program_type(user=self.user, program_type_slug=self.MICROBACHELORS, paid_modes_only=True)  # lint-amnesty, pylint: disable=line-too-long
-        )
+        assert not is_user_enrolled_in_program_type(user=self.user,
+                                                    program_type_slug=self.MICROBACHELORS,
+                                                    paid_modes_only=True)
 
     # NEW CODE HERE
     @mock.patch('openedx.core.djangoapps.programs.utils.get_paid_modes_for_course')
-    def test_user_enrolled_in_paid_only_with_no_matching_paid_course_modes(self, mock_get_paid_modes_for_course, mock_get_programs_by_type):  # lint-amnesty, pylint: disable=line-too-long
+    def test_user_enrolled_in_paid_only_with_no_matching_paid_course_modes(self, mock_get_paid_modes_for_course,
+                                                                           mock_get_programs_by_type):
         second_program = ProgramFactory(type=self.MICROBACHELORS)
         second_catalog_course_run = second_program['courses'][0]['course_runs'][0]
         second_course_key = CourseKey.from_string(second_catalog_course_run['key'])
@@ -1628,16 +1620,12 @@ class TestProgramEnrollment(SharedModuleStoreTestCase):
         # we should return False
         mock_get_paid_modes_for_course.return_value = []
         # raise Exception((mock_get_programs_by_type, mock_get_paid_modes_for_course))
-        self.assertFalse(
-            is_user_enrolled_in_program_type(user=self.user, program_type_slug=self.MICROBACHELORS, paid_modes_only=True)  # lint-amnesty, pylint: disable=line-too-long
-        )
+        assert not is_user_enrolled_in_program_type(user=self.user, program_type_slug=self.MICROBACHELORS, paid_modes_only=True)
 
         # We should continue to return false even if they do contain paid modes
         Mode = namedtuple('Mode', ['slug'])  # lint-amnesty, pylint: disable=unused-variable
         # mock_get_paid_modes_for_course.return_value = [Mode(CourseMode.VERIFIED)]
-        self.assertFalse(
-            is_user_enrolled_in_program_type(user=self.user, program_type_slug=self.MICROBACHELORS, paid_modes_only=True)  # lint-amnesty, pylint: disable=line-too-long
-        )
+        assert not is_user_enrolled_in_program_type(user=self.user, program_type_slug=self.MICROBACHELORS, paid_modes_only=True)
 
     def test_user_with_entitlement_no_enrollment(self, mock_get_programs_by_type):
         CourseEntitlementFactory.create(
@@ -1646,4 +1634,4 @@ class TestProgramEnrollment(SharedModuleStoreTestCase):
             course_uuid=self.program['courses'][0]['uuid']
         )
         mock_get_programs_by_type.return_value = [self.program]
-        self.assertTrue(is_user_enrolled_in_program_type(user=self.user, program_type_slug=self.MICROBACHELORS))
+        assert is_user_enrolled_in_program_type(user=self.user, program_type_slug=self.MICROBACHELORS)