Fixed #23620 -- Used more specific assertions in the Django test suite.

Author: berkerpeksag

django/contrib/auth/tests/test_context_processors.py

@@ -45,10 +45,10 @@ def test_permwrapper_in(self):
         """
         perms = PermWrapper(MockUser())
         # Works for modules and full permissions.
-        self.assertTrue('mockapp' in perms)
-        self.assertFalse('nonexisting' in perms)
-        self.assertTrue('mockapp.someperm' in perms)
-        self.assertFalse('mockapp.nonexisting' in perms)
+        self.assertIn('mockapp', perms)
+        self.assertNotIn('nonexisting', perms)
+        self.assertIn('mockapp.someperm', perms)
+        self.assertNotIn('mockapp.nonexisting', perms)
 
     def test_permlookupdict_in(self):
         """

django/contrib/auth/tests/test_decorators.py

@@ -42,7 +42,7 @@ def testLoginRequired(self, view_url='/login_required/', login_url=None):
             login_url = settings.LOGIN_URL
         response = self.client.get(view_url)
         self.assertEqual(response.status_code, 302)
-        self.assertTrue(login_url in response.url)
+        self.assertIn(login_url, response.url)
         self.login()
         response = self.client.get(view_url)
         self.assertEqual(response.status_code, 200)

django/contrib/auth/tests/test_handlers.py

@@ -29,7 +29,7 @@ def test_check_password(self):
         User.objects.create_user('test', '[email protected]', 'test')
 
         # User not in database
-        self.assertTrue(check_password({}, 'unknown', '') is None)
+        self.assertIsNone(check_password({}, 'unknown', ''))
 
         # Valid user with correct password
         self.assertTrue(check_password({}, 'test', 'test'))
@@ -53,7 +53,7 @@ def test_check_password_custom_user(self):
         CustomUser._default_manager.create_user('[email protected]', '1990-01-01', 'test')
 
         # User not in database
-        self.assertTrue(check_password({}, 'unknown', '') is None)
+        self.assertIsNone(check_password({}, 'unknown', ''))
 
         # Valid user with correct password'
         self.assertTrue(check_password({}, '[email protected]', 'test'))

django/contrib/auth/tests/test_signals.py

@@ -44,7 +44,7 @@ def test_login(self):
         self.assertEqual(len(self.login_failed), 1)
         self.assertEqual(self.login_failed[0]['username'], 'testclient')
         # verify the password is cleansed
-        self.assertTrue('***' in self.login_failed[0]['password'])
+        self.assertIn('***', self.login_failed[0]['password'])
 
         # Like this:
         self.client.login(username='testclient', password='password')

django/contrib/auth/tests/test_views.py

@@ -55,13 +55,13 @@ def login(self, username='testclient', password='password'):
             'username': username,
             'password': password,
         })
-        self.assertTrue(SESSION_KEY in self.client.session)
+        self.assertIn(SESSION_KEY, self.client.session)
         return response
 
     def logout(self):
         response = self.client.get('/admin/logout/')
         self.assertEqual(response.status_code, 200)
-        self.assertTrue(SESSION_KEY not in self.client.session)
+        self.assertNotIn(SESSION_KEY, self.client.session)
 
     def assertFormError(self, response, error):
         """Assert that error is found in response.context['form'] errors"""
@@ -129,7 +129,7 @@ def test_email_found(self):
         response = self.client.post('/password_reset/', {'email': '[email protected]'})
         self.assertEqual(response.status_code, 302)
         self.assertEqual(len(mail.outbox), 1)
-        self.assertTrue("http://" in mail.outbox[0].body)
+        self.assertIn("http://", mail.outbox[0].body)
         self.assertEqual(settings.DEFAULT_FROM_EMAIL, mail.outbox[0].from_email)
         # optional multipart text/html email has been added.  Make sure original,
         # default functionality is 100% the same
@@ -148,8 +148,8 @@ def test_html_mail_template(self):
         self.assertTrue(message.is_multipart())
         self.assertEqual(message.get_payload(0).get_content_type(), 'text/plain')
         self.assertEqual(message.get_payload(1).get_content_type(), 'text/html')
-        self.assertTrue('<html>' not in message.get_payload(0).get_payload())
-        self.assertTrue('<html>' in message.get_payload(1).get_payload())
+        self.assertNotIn('<html>', message.get_payload(0).get_payload())
+        self.assertIn('<html>', message.get_payload(1).get_payload())
 
     def test_email_found_custom_from(self):
         "Email is sent if a valid email address is provided for password reset when a custom from_email is provided."
@@ -169,7 +169,7 @@ def test_admin_reset(self):
             )
         self.assertEqual(response.status_code, 302)
         self.assertEqual(len(mail.outbox), 1)
-        self.assertTrue("http://adminsite.com" in mail.outbox[0].body)
+        self.assertIn("http://adminsite.com", mail.outbox[0].body)
         self.assertEqual(settings.DEFAULT_FROM_EMAIL, mail.outbox[0].from_email)
 
     # Skip any 500 handler action (like sending more mail...)
@@ -215,7 +215,7 @@ def _test_confirm_start(self):
 
     def _read_signup_email(self, email):
         urlmatch = re.search(r"https?://[^/]*(/.*reset/\S*)", email.body)
-        self.assertTrue(urlmatch is not None, "No URL found in sent email")
+        self.assertIsNotNone(urlmatch, "No URL found in sent email")
         return urlmatch.group(), urlmatch.groups()[0]
 
     def test_confirm_valid(self):
@@ -346,7 +346,7 @@ def _test_confirm_start(self):
 
     def _read_signup_email(self, email):
         urlmatch = re.search(r"https?://[^/]*(/.*reset/\S*)", email.body)
-        self.assertTrue(urlmatch is not None, "No URL found in sent email")
+        self.assertIsNotNone(urlmatch, "No URL found in sent email")
         return urlmatch.group(), urlmatch.groups()[0]
 
     def test_confirm_valid_custom_user(self):
@@ -502,7 +502,7 @@ def test_security_check(self, password='password'):
                 'password': password,
             })
             self.assertEqual(response.status_code, 302)
-            self.assertFalse(bad_url in response.url,
+            self.assertNotIn(bad_url, response.url,
                              "%s should be blocked" % bad_url)
 
         # These URLs *should* still pass the security check
@@ -524,8 +524,7 @@ def test_security_check(self, password='password'):
                 'password': password,
             })
             self.assertEqual(response.status_code, 302)
-            self.assertTrue(good_url in response.url,
-                            "%s should be allowed" % good_url)
+            self.assertIn(good_url, response.url, "%s should be allowed" % good_url)
 
     def test_login_form_contains_request(self):
         # 15198
@@ -683,7 +682,7 @@ def test_remote(self):
 class LogoutTest(AuthViewsTestCase):
 
     def confirm_logged_out(self):
-        self.assertTrue(SESSION_KEY not in self.client.session)
+        self.assertNotIn(SESSION_KEY, self.client.session)
 
     def test_logout_default(self):
         "Logout without next_page option renders the default template"
@@ -696,7 +695,7 @@ def test_14377(self):
         # Bug 14377
         self.login()
         response = self.client.get('/logout/')
-        self.assertTrue('site' in response.context)
+        self.assertIn('site', response.context)
 
     def test_logout_with_overridden_redirect_url(self):
         # Bug 11223
@@ -762,7 +761,7 @@ def test_security_check(self, password='password'):
             self.login()
             response = self.client.get(nasty_url)
             self.assertEqual(response.status_code, 302)
-            self.assertFalse(bad_url in response.url,
+            self.assertNotIn(bad_url, response.url,
                              "%s should be blocked" % bad_url)
             self.confirm_logged_out()
 
@@ -783,8 +782,7 @@ def test_security_check(self, password='password'):
             self.login()
             response = self.client.get(safe_url)
             self.assertEqual(response.status_code, 302)
-            self.assertTrue(good_url in response.url,
-                            "%s should be allowed" % good_url)
+            self.assertIn(good_url, response.url, "%s should be allowed" % good_url)
             self.confirm_logged_out()
 
     def test_logout_preserve_language(self):

django/contrib/gis/geos/tests/test_geos.py

@@ -436,17 +436,13 @@ def test_polygons(self):
     def test_polygon_comparison(self):
         p1 = Polygon(((0, 0), (0, 1), (1, 1), (1, 0), (0, 0)))
         p2 = Polygon(((0, 0), (0, 1), (1, 0), (0, 0)))
-        self.assertTrue(p1 > p2)
-        self.assertFalse(p1 < p2)
-        self.assertFalse(p2 > p1)
-        self.assertTrue(p2 < p1)
+        self.assertGreater(p1, p2)
+        self.assertLess(p2, p1)
 
         p3 = Polygon(((0, 0), (0, 1), (1, 1), (2, 0), (0, 0)))
         p4 = Polygon(((0, 0), (0, 1), (2, 2), (1, 0), (0, 0)))
-        self.assertFalse(p4 < p3)
-        self.assertTrue(p3 < p4)
-        self.assertTrue(p4 > p3)
-        self.assertFalse(p3 > p4)
+        self.assertGreater(p4, p3)
+        self.assertLess(p3, p4)
 
     def test_multipolygons(self):
         "Testing MultiPolygon objects."
@@ -911,7 +907,7 @@ def test_transform_noop(self):
             g1 = g.transform(4326, clone=True)
             self.assertEqual(g1.tuple, g.tuple)
             self.assertEqual(g1.srid, 4326)
-            self.assertTrue(g1 is not g, "Clone didn't happen")
+            self.assertIsNot(g1, g, "Clone didn't happen")
 
         old_has_gdal = gdal.HAS_GDAL
         try:
@@ -927,7 +923,7 @@ def test_transform_noop(self):
             g1 = g.transform(4326, clone=True)
             self.assertEqual(g1.tuple, g.tuple)
             self.assertEqual(g1.srid, 4326)
-            self.assertTrue(g1 is not g, "Clone didn't happen")
+            self.assertIsNot(g1, g, "Clone didn't happen")
         finally:
             gdal.HAS_GDAL = old_has_gdal
 

django/contrib/gis/geos/tests/test_mutable_list.py

@@ -391,35 +391,34 @@ def test_12_arithmetic(self):
 
         pl, ul = self.lists_of_len()
         self.assertEqual(pl, ul, 'cmp for equal')
-        self.assertFalse(ul == pl + [2], 'cmp for not equal')
-        self.assertTrue(pl >= ul, 'cmp for gte self')
-        self.assertTrue(pl <= ul, 'cmp for lte self')
-        self.assertTrue(ul >= pl, 'cmp for self gte')
-        self.assertTrue(ul <= pl, 'cmp for self lte')
-
-        self.assertTrue(pl + [5] > ul, 'cmp')
-        self.assertTrue(pl + [5] >= ul, 'cmp')
-        self.assertTrue(pl < ul + [2], 'cmp')
-        self.assertTrue(pl <= ul + [2], 'cmp')
-        self.assertTrue(ul + [5] > pl, 'cmp')
-        self.assertTrue(ul + [5] >= pl, 'cmp')
-        self.assertTrue(ul < pl + [2], 'cmp')
-        self.assertTrue(ul <= pl + [2], 'cmp')
+        self.assertNotEqual(ul, pl + [2], 'cmp for not equal')
+        self.assertGreaterEqual(pl, ul, 'cmp for gte self')
+        self.assertLessEqual(pl, ul, 'cmp for lte self')
+        self.assertGreaterEqual(ul, pl, 'cmp for self gte')
+        self.assertLessEqual(ul, pl, 'cmp for self lte')
+
+        self.assertGreater(pl + [5], ul, 'cmp')
+        self.assertGreaterEqual(pl + [5], ul, 'cmp')
+        self.assertLess(pl, ul + [2], 'cmp')
+        self.assertLessEqual(pl, ul + [2], 'cmp')
+        self.assertGreater(ul + [5], pl, 'cmp')
+        self.assertGreaterEqual(ul + [5], pl, 'cmp')
+        self.assertLess(ul, pl + [2], 'cmp')
+        self.assertLessEqual(ul, pl + [2], 'cmp')
 
         # Also works with a custom IndexError
         ul_longer = ul + [2]
         ul_longer._IndexError = TypeError
         ul._IndexError = TypeError
-        self.assertFalse(ul_longer == pl)
-        self.assertFalse(ul == ul_longer)
-        self.assertTrue(ul_longer > ul)
+        self.assertNotEqual(ul_longer, pl)
+        self.assertGreater(ul_longer, ul)
 
         pl[1] = 20
-        self.assertTrue(pl > ul, 'cmp for gt self')
-        self.assertTrue(ul < pl, 'cmp for self lt')
+        self.assertGreater(pl, ul, 'cmp for gt self')
+        self.assertLess(ul, pl, 'cmp for self lt')
         pl[1] = -20
-        self.assertTrue(pl < ul, 'cmp for lt self')
-        self.assertTrue(pl < ul, 'cmp for lt self')
+        self.assertLess(pl, ul, 'cmp for lt self')
+        self.assertGreater(ul, pl, 'cmp for gt self')
 
 
 class ListMixinTestSingle(ListMixinTest):

django/contrib/gis/tests/relatedapp/tests.py

@@ -228,8 +228,8 @@ def test10_combine(self):
         combined = qs1 | qs2
         names = [c.name for c in combined]
         self.assertEqual(2, len(names))
-        self.assertTrue('Aurora' in names)
-        self.assertTrue('Kecksburg' in names)
+        self.assertIn('Aurora', names)
+        self.assertIn('Kecksburg', names)
 
     def test11_geoquery_pickle(self):
         "Ensuring GeoQuery objects are unpickled correctly.  See #10839."

django/contrib/gis/tests/test_geoforms.py

@@ -174,7 +174,7 @@ class PointForm(forms.Form):
         self.assertFalse(PointForm().is_valid())
         invalid = PointForm(data={'p': 'some invalid geom'})
         self.assertFalse(invalid.is_valid())
-        self.assertTrue('Invalid geometry value' in str(invalid.errors))
+        self.assertIn('Invalid geometry value', str(invalid.errors))
 
         for invalid in [geo for key, geo in self.geometries.items() if key != 'point']:
             self.assertFalse(PointForm(data={'p': invalid.wkt}).is_valid())

django/contrib/gis/tests/test_measure.py

@@ -122,9 +122,9 @@ def testComparisons(self):
         d2 = D(km=1)
         d3 = D(km=0)
 
-        self.assertTrue(d2 > d1)
-        self.assertTrue(d1 == d1)
-        self.assertTrue(d1 < d2)
+        self.assertGreater(d2, d1)
+        self.assertEqual(d1, d1)
+        self.assertLess(d1, d2)
         self.assertFalse(d3)
 
     def testUnitsStr(self):
@@ -249,9 +249,9 @@ def testComparisons(self):
         a2 = A(sq_km=1)
         a3 = A(sq_km=0)
 
-        self.assertTrue(a2 > a1)
-        self.assertTrue(a1 == a1)
-        self.assertTrue(a1 < a2)
+        self.assertGreater(a2, a1)
+        self.assertEqual(a1, a1)
+        self.assertLess(a1, a2)
         self.assertFalse(a3)
 
     def testUnitsStr(self):

django/contrib/messages/tests/base.py

@@ -163,7 +163,7 @@ def test_full_request_response_cycle(self):
             add_url = reverse('add_message', args=(level,))
             response = self.client.post(add_url, data, follow=True)
             self.assertRedirects(response, show_url)
-            self.assertTrue('messages' in response.context)
+            self.assertIn('messages', response.context)
             messages = [Message(self.levels[level], msg) for msg in data['messages']]
             self.assertEqual(list(response.context['messages']), messages)
             for msg in data['messages']:
@@ -179,7 +179,7 @@ def test_with_template_response(self):
             add_url = reverse('add_template_response', args=(level,))
             response = self.client.post(add_url, data, follow=True)
             self.assertRedirects(response, show_url)
-            self.assertTrue('messages' in response.context)
+            self.assertIn('messages', response.context)
             for msg in data['messages']:
                 self.assertContains(response, msg)
 
@@ -192,7 +192,7 @@ def test_context_processor_message_levels(self):
         show_url = reverse('show_template_response')
         response = self.client.get(show_url)
 
-        self.assertTrue('DEFAULT_MESSAGE_LEVELS' in response.context)
+        self.assertIn('DEFAULT_MESSAGE_LEVELS', response.context)
         self.assertEqual(response.context['DEFAULT_MESSAGE_LEVELS'], DEFAULT_LEVELS)
 
     @override_settings(MESSAGE_LEVEL=constants.DEBUG)
@@ -211,7 +211,7 @@ def test_multiple_posts(self):
             add_url = reverse('add_message', args=(level,))
             self.client.post(add_url, data)
         response = self.client.get(show_url)
-        self.assertTrue('messages' in response.context)
+        self.assertIn('messages', response.context)
         self.assertEqual(list(response.context['messages']), messages)
         for msg in data['messages']:
             self.assertContains(response, msg)
@@ -255,7 +255,7 @@ def test_middleware_disabled_fail_silently(self):
             add_url = reverse('add_message', args=(level,))
             response = self.client.post(add_url, data, follow=True)
             self.assertRedirects(response, show_url)
-            self.assertFalse('messages' in response.context)
+            self.assertNotIn('messages', response.context)
 
     def stored_messages_count(self, storage, response):
         """

django/contrib/messages/tests/test_cookie.py

@@ -65,7 +65,7 @@ def test_cookie_setings(self):
         response = self.get_response()
         storage.add(constants.INFO, 'test')
         storage.update(response)
-        self.assertTrue('test' in response.cookies['messages'].value)
+        self.assertIn('test', response.cookies['messages'].value)
         self.assertEqual(response.cookies['messages']['domain'], '.example.com')
         self.assertEqual(response.cookies['messages']['expires'], '')
         self.assertEqual(response.cookies['messages']['secure'], True)
@@ -114,7 +114,7 @@ def test_max_cookie_length(self):
         self.assertEqual(cookie_storing, 4)
 
         self.assertEqual(len(unstored_messages), 1)
-        self.assertTrue(unstored_messages[0].message == '0' * msg_size)
+        self.assertEqual(unstored_messages[0].message, '0' * msg_size)
 
     def test_json_encoder_decoder(self):
         """

django/contrib/sessions/tests.py

@@ -286,7 +286,7 @@ def test_decode_failure_logged_to_security(self):
             self.assertEqual({}, self.session.decode(bad_encode))
             # check that the failed decode is logged
             self.assertEqual(len(calls), 1)
-            self.assertTrue('corrupted' in calls[0])
+            self.assertIn('corrupted', calls[0])
 
     def test_actual_expiry(self):
         # this doesn't work with JSONSerializer (serializing timedelta)