Merge pull request #947 from upstream-janitor/teyit

Improve assertions in Python unit tests

dulwich/tests/compat/test_client.py

@@ -337,7 +337,7 @@ class DulwichClientTestBase(object):
             c = self._client()
             self.assertEqual(dest.refs[b"refs/heads/abranch"], dummy_commit)
             c.send_pack(self._build_path("/dest"), lambda _: sendrefs, gen_pack)
-            self.assertFalse(b"refs/heads/abranch" in dest.refs)
+            self.assertNotIn(b"refs/heads/abranch", dest.refs)
 
     def test_send_new_branch_empty_pack(self):
         with repo.Repo(os.path.join(self.gitroot, "dest")) as dest:

dulwich/tests/compat/test_server.py

@@ -59,7 +59,7 @@ class GitServerTestCase(ServerTests, CompatTestCase):
     def _check_server(self, dul_server):
         receive_pack_handler_cls = dul_server.handlers[b"git-receive-pack"]
         caps = receive_pack_handler_cls.capabilities()
-        self.assertFalse(b"side-band-64k" in caps)
+        self.assertNotIn(b"side-band-64k", caps)
 
     def _start_server(self, repo):
         backend = DictBackend({b"/": repo})
@@ -94,4 +94,4 @@ class GitServerSideBand64kTestCase(GitServerTestCase):
     def _check_server(self, server):
         receive_pack_handler_cls = server.handlers[b"git-receive-pack"]
         caps = receive_pack_handler_cls.capabilities()
-        self.assertTrue(b"side-band-64k" in caps)
+        self.assertIn(b"side-band-64k", caps)

dulwich/tests/test_client.py

@@ -427,21 +427,21 @@ class GitClientTests(TestCase):
 class TestGetTransportAndPath(TestCase):
     def test_tcp(self):
         c, path = get_transport_and_path("git://foo.com/bar/baz")
-        self.assertTrue(isinstance(c, TCPGitClient))
+        self.assertIsInstance(c, TCPGitClient)
         self.assertEqual("foo.com", c._host)
         self.assertEqual(TCP_GIT_PORT, c._port)
         self.assertEqual("/bar/baz", path)
 
     def test_tcp_port(self):
         c, path = get_transport_and_path("git://foo.com:1234/bar/baz")
-        self.assertTrue(isinstance(c, TCPGitClient))
+        self.assertIsInstance(c, TCPGitClient)
         self.assertEqual("foo.com", c._host)
         self.assertEqual(1234, c._port)
         self.assertEqual("/bar/baz", path)
 
     def test_git_ssh_explicit(self):
         c, path = get_transport_and_path("git+ssh://foo.com/bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
@@ -449,7 +449,7 @@ class TestGetTransportAndPath(TestCase):
 
     def test_ssh_explicit(self):
         c, path = get_transport_and_path("ssh://foo.com/bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
@@ -457,20 +457,20 @@ class TestGetTransportAndPath(TestCase):
 
     def test_ssh_port_explicit(self):
         c, path = get_transport_and_path("git+ssh://foo.com:1234/bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("foo.com", c.host)
         self.assertEqual(1234, c.port)
         self.assertEqual("/bar/baz", path)
 
     def test_username_and_port_explicit_unknown_scheme(self):
         c, path = get_transport_and_path("unknown://git@server:7999/dply/stuff.git")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("unknown", c.host)
         self.assertEqual("//git@server:7999/dply/stuff.git", path)
 
     def test_username_and_port_explicit(self):
         c, path = get_transport_and_path("ssh://git@server:7999/dply/stuff.git")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("git", c.username)
         self.assertEqual("server", c.host)
         self.assertEqual(7999, c.port)
@@ -478,7 +478,7 @@ class TestGetTransportAndPath(TestCase):
 
     def test_ssh_abspath_doubleslash(self):
         c, path = get_transport_and_path("git+ssh://foo.com//bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
@@ -486,14 +486,14 @@ class TestGetTransportAndPath(TestCase):
 
     def test_ssh_port(self):
         c, path = get_transport_and_path("git+ssh://foo.com:1234/bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("foo.com", c.host)
         self.assertEqual(1234, c.port)
         self.assertEqual("/bar/baz", path)
 
     def test_ssh_implicit(self):
         c, path = get_transport_and_path("foo:/bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("foo", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
@@ -501,7 +501,7 @@ class TestGetTransportAndPath(TestCase):
 
     def test_ssh_host(self):
         c, path = get_transport_and_path("foo.com:/bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
@@ -509,7 +509,7 @@ class TestGetTransportAndPath(TestCase):
 
     def test_ssh_user_host(self):
         c, path = get_transport_and_path("user@foo.com:/bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual("user", c.username)
@@ -517,7 +517,7 @@ class TestGetTransportAndPath(TestCase):
 
     def test_ssh_relpath(self):
         c, path = get_transport_and_path("foo:bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("foo", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
@@ -525,7 +525,7 @@ class TestGetTransportAndPath(TestCase):
 
     def test_ssh_host_relpath(self):
         c, path = get_transport_and_path("foo.com:bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
@@ -533,7 +533,7 @@ class TestGetTransportAndPath(TestCase):
 
     def test_ssh_user_host_relpath(self):
         c, path = get_transport_and_path("user@foo.com:bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual("user", c.username)
@@ -541,25 +541,25 @@ class TestGetTransportAndPath(TestCase):
 
     def test_local(self):
         c, path = get_transport_and_path("foo.bar/baz")
-        self.assertTrue(isinstance(c, LocalGitClient))
+        self.assertIsInstance(c, LocalGitClient)
         self.assertEqual("foo.bar/baz", path)
 
     @skipIf(sys.platform != "win32", "Behaviour only happens on windows.")
     def test_local_abs_windows_path(self):
         c, path = get_transport_and_path("C:\\foo.bar\\baz")
-        self.assertTrue(isinstance(c, LocalGitClient))
+        self.assertIsInstance(c, LocalGitClient)
         self.assertEqual("C:\\foo.bar\\baz", path)
 
     def test_error(self):
         # Need to use a known urlparse.uses_netloc URL scheme to get the
         # expected parsing of the URL on Python versions less than 2.6.5
         c, path = get_transport_and_path("prospero://bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
 
     def test_http(self):
         url = "https://github.com/jelmer/dulwich"
         c, path = get_transport_and_path(url)
-        self.assertTrue(isinstance(c, HttpGitClient))
+        self.assertIsInstance(c, HttpGitClient)
         self.assertEqual("/jelmer/dulwich", path)
 
     def test_http_auth(self):
@@ -567,7 +567,7 @@ class TestGetTransportAndPath(TestCase):
 
         c, path = get_transport_and_path(url)
 
-        self.assertTrue(isinstance(c, HttpGitClient))
+        self.assertIsInstance(c, HttpGitClient)
         self.assertEqual("/jelmer/dulwich", path)
         self.assertEqual("user", c._username)
         self.assertEqual("passwd", c._password)
@@ -577,7 +577,7 @@ class TestGetTransportAndPath(TestCase):
 
         c, path = get_transport_and_path(url, username="user2", password="blah")
 
-        self.assertTrue(isinstance(c, HttpGitClient))
+        self.assertIsInstance(c, HttpGitClient)
         self.assertEqual("/jelmer/dulwich", path)
         self.assertEqual("user2", c._username)
         self.assertEqual("blah", c._password)
@@ -587,7 +587,7 @@ class TestGetTransportAndPath(TestCase):
 
         c, path = get_transport_and_path(url, username="user2", password="blah")
 
-        self.assertTrue(isinstance(c, HttpGitClient))
+        self.assertIsInstance(c, HttpGitClient)
         self.assertEqual("/jelmer/dulwich", path)
         self.assertEqual("user", c._username)
         self.assertEqual("passwd", c._password)
@@ -597,7 +597,7 @@ class TestGetTransportAndPath(TestCase):
 
         c, path = get_transport_and_path(url)
 
-        self.assertTrue(isinstance(c, HttpGitClient))
+        self.assertIsInstance(c, HttpGitClient)
         self.assertEqual("/jelmer/dulwich", path)
         self.assertIs(None, c._username)
         self.assertIs(None, c._password)
@@ -606,21 +606,21 @@ class TestGetTransportAndPath(TestCase):
 class TestGetTransportAndPathFromUrl(TestCase):
     def test_tcp(self):
         c, path = get_transport_and_path_from_url("git://foo.com/bar/baz")
-        self.assertTrue(isinstance(c, TCPGitClient))
+        self.assertIsInstance(c, TCPGitClient)
         self.assertEqual("foo.com", c._host)
         self.assertEqual(TCP_GIT_PORT, c._port)
         self.assertEqual("/bar/baz", path)
 
     def test_tcp_port(self):
         c, path = get_transport_and_path_from_url("git://foo.com:1234/bar/baz")
-        self.assertTrue(isinstance(c, TCPGitClient))
+        self.assertIsInstance(c, TCPGitClient)
         self.assertEqual("foo.com", c._host)
         self.assertEqual(1234, c._port)
         self.assertEqual("/bar/baz", path)
 
     def test_ssh_explicit(self):
         c, path = get_transport_and_path_from_url("git+ssh://foo.com/bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
@@ -628,14 +628,14 @@ class TestGetTransportAndPathFromUrl(TestCase):
 
     def test_ssh_port_explicit(self):
         c, path = get_transport_and_path_from_url("git+ssh://foo.com:1234/bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("foo.com", c.host)
         self.assertEqual(1234, c.port)
         self.assertEqual("/bar/baz", path)
 
     def test_ssh_homepath(self):
         c, path = get_transport_and_path_from_url("git+ssh://foo.com/~/bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
@@ -643,7 +643,7 @@ class TestGetTransportAndPathFromUrl(TestCase):
 
     def test_ssh_port_homepath(self):
         c, path = get_transport_and_path_from_url("git+ssh://foo.com:1234/~/bar/baz")
-        self.assertTrue(isinstance(c, SSHGitClient))
+        self.assertIsInstance(c, SSHGitClient)
         self.assertEqual("foo.com", c.host)
         self.assertEqual(1234, c.port)
         self.assertEqual("/~/bar/baz", path)
@@ -671,7 +671,7 @@ class TestGetTransportAndPathFromUrl(TestCase):
     def test_http(self):
         url = "https://github.com/jelmer/dulwich"
         c, path = get_transport_and_path_from_url(url)
-        self.assertTrue(isinstance(c, HttpGitClient))
+        self.assertIsInstance(c, HttpGitClient)
         self.assertEqual("https://github.com", c.get_url(b"/"))
         self.assertEqual("/jelmer/dulwich", path)
 
@@ -679,12 +679,12 @@ class TestGetTransportAndPathFromUrl(TestCase):
         url = "https://github.com:9090/jelmer/dulwich"
         c, path = get_transport_and_path_from_url(url)
         self.assertEqual("https://github.com:9090", c.get_url(b"/"))
-        self.assertTrue(isinstance(c, HttpGitClient))
+        self.assertIsInstance(c, HttpGitClient)
         self.assertEqual("/jelmer/dulwich", path)
 
     def test_file(self):
         c, path = get_transport_and_path_from_url("file:///home/jelmer/foo")
-        self.assertTrue(isinstance(c, LocalGitClient))
+        self.assertIsInstance(c, LocalGitClient)
         self.assertEqual("/home/jelmer/foo", path)
 
 

dulwich/tests/test_fastexport.py

@@ -197,8 +197,8 @@ M 100644 :1 a
             )
         )
         self.assertEqual(2, len(markers))
-        self.assertTrue(isinstance(self.repo[markers[b"1"]], Blob))
-        self.assertTrue(isinstance(self.repo[markers[b"2"]], Commit))
+        self.assertIsInstance(self.repo[markers[b"1"]], Blob)
+        self.assertIsInstance(self.repo[markers[b"2"]], Commit)
 
     def test_file_add(self):
         from fastimport import commands

dulwich/tests/test_file.py

@@ -112,7 +112,7 @@ class GitFileTests(TestCase):
 
     def test_readonly(self):
         f = GitFile(self.path("foo"), "rb")
-        self.assertTrue(isinstance(f, io.IOBase))
+        self.assertIsInstance(f, io.IOBase)
         self.assertEqual(b"foo contents", f.read())
         self.assertEqual(b"", f.read())
         f.seek(4)

dulwich/tests/test_lru_cache.py

@@ -43,18 +43,18 @@ class TestLRUCache(TestCase):
     def test_missing(self):
         cache = lru_cache.LRUCache(max_cache=10)
 
-        self.assertFalse("foo" in cache)
+        self.assertNotIn("foo", cache)
         self.assertRaises(KeyError, cache.__getitem__, "foo")
 
         cache["foo"] = "bar"
         self.assertEqual("bar", cache["foo"])
-        self.assertTrue("foo" in cache)
-        self.assertFalse("bar" in cache)
+        self.assertIn("foo", cache)
+        self.assertNotIn("bar", cache)
 
     def test_map_None(self):
         # Make sure that we can properly map None as a key.
         cache = lru_cache.LRUCache(max_cache=10)
-        self.assertFalse(None in cache)
+        self.assertNotIn(None, cache)
         cache[None] = 1
         self.assertEqual(1, cache[None])
         cache[None] = 2
@@ -80,8 +80,8 @@ class TestLRUCache(TestCase):
         # With a max cache of 1, adding 'baz' should pop out 'foo'
         cache["baz"] = "biz"
 
-        self.assertFalse("foo" in cache)
-        self.assertTrue("baz" in cache)
+        self.assertNotIn("foo", cache)
+        self.assertIn("baz", cache)
 
         self.assertEqual("biz", cache["baz"])
 
@@ -97,7 +97,7 @@ class TestLRUCache(TestCase):
         # This must kick out 'foo' because it was the last accessed
         cache["nub"] = "in"
 
-        self.assertFalse("foo" in cache)
+        self.assertNotIn("foo", cache)
 
     def test_cleanup(self):
         """Test that we can use a cleanup function."""
@@ -236,7 +236,7 @@ class TestLRUCache(TestCase):
         self.assertEqual(20, cache.get(2))
         self.assertEqual(None, cache.get(3))
         obj = object()
-        self.assertTrue(obj is cache.get(3, obj))
+        self.assertIs(obj, cache.get(3, obj))
         self.assertEqual([2, 1], [n.key for n in cache._walk_lru()])
         self.assertEqual(10, cache.get(1))
         self.assertEqual([1, 2], [n.key for n in cache._walk_lru()])

dulwich/tests/test_missing_obj_finder.py

@@ -43,9 +43,10 @@ class MissingObjectFinderTest(TestCase):
 
     def assertMissingMatch(self, haves, wants, expected):
         for sha, path in self.store.find_missing_objects(haves, wants, set()):
-            self.assertTrue(
-                sha in expected,
-                "(%s,%s) erroneously reported as missing" % (sha, path),
+            self.assertIn(
+                sha,
+                expected,
+                "(%s,%s) erroneously reported as missing" % (sha, path)
             )
             expected.remove(sha)
 

dulwich/tests/test_object_store.py

@@ -138,7 +138,7 @@ class ObjectStoreTests(object):
         self.assertRaises(KeyError, lambda: self.store[b"a" * 40])
 
     def test_contains_nonexistant(self):
-        self.assertFalse((b"a" * 40) in self.store)
+        self.assertNotIn(b"a" * 40, self.store)
 
     def test_add_objects_empty(self):
         self.store.add_objects([])
@@ -165,7 +165,7 @@ class ObjectStoreTests(object):
     def test_add_object(self):
         self.store.add_object(testobject)
         self.assertEqual(set([testobject.id]), set(self.store))
-        self.assertTrue(testobject.id in self.store)
+        self.assertIn(testobject.id, self.store)
         r = self.store[testobject.id]
         self.assertEqual(r, testobject)
 
@@ -173,7 +173,7 @@ class ObjectStoreTests(object):
         data = [(testobject, "mypath")]
         self.store.add_objects(data)
         self.assertEqual(set([testobject.id]), set(self.store))
-        self.assertTrue(testobject.id in self.store)
+        self.assertIn(testobject.id, self.store)
         r = self.store[testobject.id]
         self.assertEqual(r, testobject)
 
@@ -593,15 +593,15 @@ class TreeLookupPathTests(TestCase):
 
     def test_lookup_blob(self):
         o_id = tree_lookup_path(self.get_object, self.tree_id, b"a")[1]
-        self.assertTrue(isinstance(self.store[o_id], Blob))
+        self.assertIsInstance(self.store[o_id], Blob)
 
     def test_lookup_tree(self):
         o_id = tree_lookup_path(self.get_object, self.tree_id, b"ad")[1]
-        self.assertTrue(isinstance(self.store[o_id], Tree))
+        self.assertIsInstance(self.store[o_id], Tree)
         o_id = tree_lookup_path(self.get_object, self.tree_id, b"ad/bd")[1]
-        self.assertTrue(isinstance(self.store[o_id], Tree))
+        self.assertIsInstance(self.store[o_id], Tree)
         o_id = tree_lookup_path(self.get_object, self.tree_id, b"ad/bd/")[1]
-        self.assertTrue(isinstance(self.store[o_id], Tree))
+        self.assertIsInstance(self.store[o_id], Tree)
 
     def test_lookup_submodule(self):
         tree_lookup_path(self.get_object, self.tree_id, b"d")[1]

dulwich/tests/test_objects.py

@@ -267,7 +267,7 @@ class BlobReadTests(TestCase):
     def test_stub_sha(self):
         sha = b"5" * 40
         c = make_commit(id=sha, message=b"foo")
-        self.assertTrue(isinstance(c, Commit))
+        self.assertIsInstance(c, Commit)
         self.assertEqual(sha, c.id)
         self.assertNotEqual(sha, c.sha())
 
@@ -333,7 +333,7 @@ class CommitSerializationTests(TestCase):
 
     def test_encoding(self):
         c = self.make_commit(encoding=b"iso8859-1")
-        self.assertTrue(b"encoding iso8859-1\n" in c.as_raw_string())
+        self.assertIn(b"encoding iso8859-1\n", c.as_raw_string())
 
     def test_short_timestamp(self):
         c = self.make_commit(commit_time=30)
@@ -373,11 +373,11 @@ class CommitSerializationTests(TestCase):
 
     def test_timezone(self):
         c = self.make_commit(commit_timezone=(5 * 60))
-        self.assertTrue(b" +0005\n" in c.as_raw_string())
+        self.assertIn(b" +0005\n", c.as_raw_string())
 
     def test_neg_timezone(self):
         c = self.make_commit(commit_timezone=(-1 * 3600))
-        self.assertTrue(b" -0100\n" in c.as_raw_string())
+        self.assertIn(b" -0100\n", c.as_raw_string())
 
     def test_deserialize(self):
         c = self.make_commit()
@@ -904,7 +904,7 @@ class TreeTests(ShaFileCheckTests):
 
         actual = do_sort(_TREE_ITEMS)
         self.assertEqual(_SORTED_TREE_ITEMS, actual)
-        self.assertTrue(isinstance(actual[0], TreeEntry))
+        self.assertIsInstance(actual[0], TreeEntry)
 
         # C/Python implementations may differ in specific error types, but
         # should all error on invalid inputs.
@@ -1295,9 +1295,9 @@ class ShaFileCopyTests(TestCase):
         oclass = object_class(orig.type_num)
 
         copy = orig.copy()
-        self.assertTrue(isinstance(copy, oclass))
+        self.assertIsInstance(copy, oclass)
         self.assertEqual(copy, orig)
-        self.assertTrue(copy is not orig)
+        self.assertIsNot(copy, orig)
 
     def test_commit_copy(self):
         attrs = {

dulwich/tests/test_pack.py

@@ -390,7 +390,7 @@ class TestPack(PackTests):
 
     def test_contains(self):
         with self.get_pack(pack1_sha) as p:
-            self.assertTrue(tree_sha in p)
+            self.assertIn(tree_sha, p)
 
     def test_get(self):
         with self.get_pack(pack1_sha) as p:
@@ -527,9 +527,9 @@ class TestPack(PackTests):
             objs = {o.id: o for o in p.iterobjects()}
             self.assertEqual(3, len(objs))
             self.assertEqual(sorted(objs), sorted(p.index))
-            self.assertTrue(isinstance(objs[a_sha], Blob))
-            self.assertTrue(isinstance(objs[tree_sha], Tree))
-            self.assertTrue(isinstance(objs[commit_sha], Commit))
+            self.assertIsInstance(objs[a_sha], Blob)
+            self.assertIsInstance(objs[tree_sha], Tree)
+            self.assertIsInstance(objs[commit_sha], Commit)
 
 
 class TestThinPack(PackTests):
@@ -703,7 +703,7 @@ class BaseTestPackIndexWriting(object):
             if self._has_crc32_checksum:
                 self.assertEqual(my_crc, actual_crc)
             else:
-                self.assertTrue(actual_crc is None)
+                self.assertIsNone(actual_crc)
 
     def test_single(self):
         entry_sha = hex_to_sha("6f670c0fb53f9463760b7295fbb814e965fb20c8")
@@ -721,7 +721,7 @@ class BaseTestPackIndexWriting(object):
             if self._has_crc32_checksum:
                 self.assertEqual(my_crc, actual_crc)
             else:
-                self.assertTrue(actual_crc is None)
+                self.assertIsNone(actual_crc)
 
 
 class BaseTestFilePackIndexWriting(BaseTestPackIndexWriting):
@@ -992,9 +992,10 @@ class DeltaChainIteratorTests(TestCase):
     def get_raw_no_repeat(self, bin_sha):
         """Wrapper around store.get_raw that doesn't allow repeat lookups."""
         hex_sha = sha_to_hex(bin_sha)
-        self.assertFalse(
-            hex_sha in self.fetched,
-            "Attempted to re-fetch object %s" % hex_sha,
+        self.assertNotIn(
+            hex_sha,
+            self.fetched,
+            "Attempted to re-fetch object %s" % hex_sha
         )
         self.fetched.add(hex_sha)
         return self.store.get_raw(hex_sha)

dulwich/tests/test_porcelain.py

@@ -327,7 +327,7 @@ class CommitTests(PorcelainTestCase):
             author=b"Joe <joe@example.com>",
             committer=b"Bob <bob@example.com>",
         )
-        self.assertTrue(isinstance(sha, bytes))
+        self.assertIsInstance(sha, bytes)
         self.assertEqual(len(sha), 40)
 
     def test_unicode(self):
@@ -341,7 +341,7 @@ class CommitTests(PorcelainTestCase):
             author="Joe <joe@example.com>",
             committer="Bob <bob@example.com>",
         )
-        self.assertTrue(isinstance(sha, bytes))
+        self.assertIsInstance(sha, bytes)
         self.assertEqual(len(sha), 40)
 
     def test_no_verify(self):
@@ -395,7 +395,7 @@ class CommitTests(PorcelainTestCase):
             committer="Bob <bob@example.com>",
             no_verify=True,
         )
-        self.assertTrue(isinstance(sha, bytes))
+        self.assertIsInstance(sha, bytes)
         self.assertEqual(len(sha), 40)
 
 
@@ -519,8 +519,8 @@ class CloneTests(PorcelainTestCase):
         target_repo = Repo(target_path)
         self.assertEqual(0, len(target_repo.open_index()))
         self.assertEqual(c3.id, target_repo.refs[b"refs/tags/foo"])
-        self.assertTrue(b"f1" not in os.listdir(target_path))
-        self.assertTrue(b"f2" not in os.listdir(target_path))
+        self.assertNotIn(b"f1", os.listdir(target_path))
+        self.assertNotIn(b"f2", os.listdir(target_path))
         c = r.get_config()
         encoded_path = self.repo.path
         if not isinstance(encoded_path, bytes):
@@ -551,8 +551,8 @@ class CloneTests(PorcelainTestCase):
             self.assertEqual(r.path, target_path)
         with Repo(target_path) as r:
             self.assertEqual(r.head(), c3.id)
-        self.assertTrue("f1" in os.listdir(target_path))
-        self.assertTrue("f2" in os.listdir(target_path))
+        self.assertIn("f1", os.listdir(target_path))
+        self.assertIn("f2", os.listdir(target_path))
 
     def test_bare_local_with_checkout(self):
         f1_1 = make_object(Blob, data=b"f1")
@@ -575,8 +575,8 @@ class CloneTests(PorcelainTestCase):
         with Repo(target_path) as r:
             r.head()
             self.assertRaises(NoIndexPresent, r.open_index)
-        self.assertFalse(b"f1" in os.listdir(target_path))
-        self.assertFalse(b"f2" in os.listdir(target_path))
+        self.assertNotIn(b"f1", os.listdir(target_path))
+        self.assertNotIn(b"f2", os.listdir(target_path))
 
     def test_no_checkout_with_bare(self):
         f1_1 = make_object(Blob, data=b"f1")
@@ -1094,7 +1094,7 @@ class CommitTreeTests(PorcelainTestCase):
             author=b"Joe <joe@example.com>",
             committer=b"Jane <jane@example.com>",
         )
-        self.assertTrue(isinstance(sha, bytes))
+        self.assertIsInstance(sha, bytes)
         self.assertEqual(len(sha), 40)
 
 
@@ -1135,7 +1135,7 @@ class TagCreateSignTests(PorcelainGpgTestCase):
         tags = self.repo.refs.as_dict(b"refs/tags")
         self.assertEqual(list(tags.keys()), [b"tryme"])
         tag = self.repo[b"refs/tags/tryme"]
-        self.assertTrue(isinstance(tag, Tag))
+        self.assertIsInstance(tag, Tag)
         self.assertEqual(b"foo <foo@bar.com>", tag.tagger)
         self.assertEqual(b"bar\n", tag.message)
         self.assertLess(time.time() - tag.tag_time, 5)
@@ -1178,7 +1178,7 @@ class TagCreateSignTests(PorcelainGpgTestCase):
         tags = self.repo.refs.as_dict(b"refs/tags")
         self.assertEqual(list(tags.keys()), [b"tryme"])
         tag = self.repo[b"refs/tags/tryme"]
-        self.assertTrue(isinstance(tag, Tag))
+        self.assertIsInstance(tag, Tag)
         self.assertEqual(b"foo <foo@bar.com>", tag.tagger)
         self.assertEqual(b"bar\n", tag.message)
         self.assertLess(time.time() - tag.tag_time, 5)
@@ -1205,7 +1205,7 @@ class TagCreateTests(PorcelainTestCase):
         tags = self.repo.refs.as_dict(b"refs/tags")
         self.assertEqual(list(tags.keys()), [b"tryme"])
         tag = self.repo[b"refs/tags/tryme"]
-        self.assertTrue(isinstance(tag, Tag))
+        self.assertIsInstance(tag, Tag)
         self.assertEqual(b"foo <foo@bar.com>", tag.tagger)
         self.assertEqual(b"bar\n", tag.message)
         self.assertLess(time.time() - tag.tag_time, 5)
@@ -1255,9 +1255,9 @@ class TagDeleteTests(PorcelainTestCase):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo[b"HEAD"] = c1.id
         porcelain.tag_create(self.repo, b"foo")
-        self.assertTrue(b"foo" in porcelain.tag_list(self.repo))
+        self.assertIn(b"foo", porcelain.tag_list(self.repo))
         porcelain.tag_delete(self.repo, b"foo")
-        self.assertFalse(b"foo" in porcelain.tag_list(self.repo))
+        self.assertNotIn(b"foo", porcelain.tag_list(self.repo))
 
 
 class ResetTests(PorcelainTestCase):
@@ -2254,17 +2254,17 @@ class BranchDeleteTests(PorcelainTestCase):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo[b"HEAD"] = c1.id
         porcelain.branch_create(self.repo, b"foo")
-        self.assertTrue(b"foo" in porcelain.branch_list(self.repo))
+        self.assertIn(b"foo", porcelain.branch_list(self.repo))
         porcelain.branch_delete(self.repo, b"foo")
-        self.assertFalse(b"foo" in porcelain.branch_list(self.repo))
+        self.assertNotIn(b"foo", porcelain.branch_list(self.repo))
 
     def test_simple_unicode(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo[b"HEAD"] = c1.id
         porcelain.branch_create(self.repo, "foo")
-        self.assertTrue(b"foo" in porcelain.branch_list(self.repo))
+        self.assertIn(b"foo", porcelain.branch_list(self.repo))
         porcelain.branch_delete(self.repo, "foo")
-        self.assertFalse(b"foo" in porcelain.branch_list(self.repo))
+        self.assertNotIn(b"foo", porcelain.branch_list(self.repo))
 
 
 class FetchTests(PorcelainTestCase):
@@ -2301,7 +2301,7 @@ class FetchTests(PorcelainTestCase):
             committer=b"test2 <email>",
         )
 
-        self.assertFalse(self.repo[b"HEAD"].id in target_repo)
+        self.assertNotIn(self.repo[b"HEAD"].id, target_repo)
         target_repo.close()
 
         # Fetch changes into the cloned repo
@@ -2312,7 +2312,7 @@ class FetchTests(PorcelainTestCase):
 
         # Check the target repo for pushed changes
         with Repo(target_path) as r:
-            self.assertTrue(self.repo[b"HEAD"].id in r)
+            self.assertIn(self.repo[b"HEAD"].id, r)
 
     def test_with_remote_name(self):
         remote_name = "origin"
@@ -2351,7 +2351,7 @@ class FetchTests(PorcelainTestCase):
             committer=b"test2 <email>",
         )
 
-        self.assertFalse(self.repo[b"HEAD"].id in target_repo)
+        self.assertNotIn(self.repo[b"HEAD"].id, target_repo)
 
         target_config = target_repo.get_config()
         target_config.set(
@@ -2370,7 +2370,7 @@ class FetchTests(PorcelainTestCase):
         # Check the target repo for pushed changes, as well as updates
         # for the refs
         with Repo(target_path) as r:
-            self.assertTrue(self.repo[b"HEAD"].id in r)
+            self.assertIn(self.repo[b"HEAD"].id, r)
             self.assertNotEqual(self.repo.get_refs(), target_refs)
 
     def assert_correct_remote_refs(

dulwich/tests/test_refs.py

@@ -274,7 +274,7 @@ class RefsContainerTests(object):
 
     def test_set_symbolic_ref_overwrite(self):
         nines = b"9" * 40
-        self.assertFalse(b"refs/heads/symbolic" in self._refs)
+        self.assertNotIn(b"refs/heads/symbolic", self._refs)
         self._refs[b"refs/heads/symbolic"] = nines
         self.assertEqual(nines, self._refs.read_loose_ref(b"refs/heads/symbolic"))
         self._refs.set_symbolic_ref(b"refs/heads/symbolic", b"refs/heads/master")
@@ -298,8 +298,8 @@ class RefsContainerTests(object):
         )
 
     def test_contains(self):
-        self.assertTrue(b"refs/heads/master" in self._refs)
-        self.assertFalse(b"refs/heads/bar" in self._refs)
+        self.assertIn(b"refs/heads/master", self._refs)
+        self.assertNotIn(b"refs/heads/bar", self._refs)
 
     def test_delitem(self):
         self.assertEqual(
@@ -321,7 +321,7 @@ class RefsContainerTests(object):
             )
         )
         self.assertTrue(self._refs.remove_if_equals(b"refs/tags/refs-0.2", ZERO_SHA))
-        self.assertFalse(b"refs/tags/refs-0.2" in self._refs)
+        self.assertNotIn(b"refs/tags/refs-0.2", self._refs)
 
     def test_import_refs_name(self):
         self._refs[
@@ -526,7 +526,7 @@ class DiskRefsContainerTests(RefsContainerTests, TestCase):
 
         nines = b"9" * 40
         self.assertEqual(b"ref: refs/heads/master", refs.read_ref(b"HEAD"))
-        self.assertFalse(b"refs/heads/master" in refs)
+        self.assertNotIn(b"refs/heads/master", refs)
         self.assertTrue(refs.add_if_new(b"HEAD", nines))
         self.assertEqual(b"ref: refs/heads/master", refs.read_ref(b"HEAD"))
         self.assertEqual(nines, refs[b"HEAD"])
@@ -556,7 +556,7 @@ class DiskRefsContainerTests(RefsContainerTests, TestCase):
         RefsContainerTests.test_delitem(self)
         ref_file = os.path.join(self._refs.path, b"refs", b"heads", b"master")
         self.assertFalse(os.path.exists(ref_file))
-        self.assertFalse(b"refs/heads/master" in self._refs.get_packed_refs())
+        self.assertNotIn(b"refs/heads/master", self._refs.get_packed_refs())
 
     def test_delitem_symbolic(self):
         self.assertEqual(b"ref: refs/heads/master", self._refs.read_loose_ref(b"HEAD"))
@@ -745,8 +745,8 @@ class InfoRefsContainerTests(TestCase):
 
     def test_contains(self):
         refs = InfoRefsContainer(BytesIO(_TEST_REFS_SERIALIZED))
-        self.assertTrue(b"refs/heads/master" in refs)
-        self.assertFalse(b"refs/heads/bar" in refs)
+        self.assertIn(b"refs/heads/master", refs)
+        self.assertNotIn(b"refs/heads/bar", refs)
 
     def test_get_peeled(self):
         refs = InfoRefsContainer(BytesIO(_TEST_REFS_SERIALIZED))

dulwich/tests/test_repository.py

@@ -75,12 +75,12 @@ class CreateRepositoryTests(TestCase):
         barestr = b"bare = " + str(expect_bare).lower().encode("ascii")
         with repo.get_named_file("config") as f:
             config_text = f.read()
-            self.assertTrue(barestr in config_text, "%r" % config_text)
+            self.assertIn(barestr, config_text, "%r" % config_text)
         expect_filemode = sys.platform != "win32"
         barestr = b"filemode = " + str(expect_filemode).lower().encode("ascii")
         with repo.get_named_file("config") as f:
             config_text = f.read()
-            self.assertTrue(barestr in config_text, "%r" % config_text)
+            self.assertIn(barestr, config_text, "%r" % config_text)
 
         if isinstance(repo, Repo):
             expected_mode = '0o100644' if expect_filemode else '0o100666'
@@ -224,12 +224,12 @@ class RepositoryRootTests(TestCase):
 
     def test_contains_object(self):
         r = self.open_repo("a.git")
-        self.assertTrue(r.head() in r)
-        self.assertFalse(b"z" * 40 in r)
+        self.assertIn(r.head(), r)
+        self.assertNotIn(b"z" * 40, r)
 
     def test_contains_ref(self):
         r = self.open_repo("a.git")
-        self.assertTrue(b"HEAD" in r)
+        self.assertIn(b"HEAD", r)
 
     def test_get_no_description(self):
         r = self.open_repo("a.git")
@@ -249,7 +249,7 @@ class RepositoryRootTests(TestCase):
 
     def test_contains_missing(self):
         r = self.open_repo("a.git")
-        self.assertFalse(b"bar" in r)
+        self.assertNotIn(b"bar", r)
 
     def test_get_peeled(self):
         # unpacked ref
@@ -1210,7 +1210,7 @@ class BuildRepoRootTests(TestCase):
         self.assertEqual(self._root_commit, r[b"HEAD"].id)
         self.assertEqual(commit_sha, r[b"refs/heads/new_branch"].id)
         self.assertEqual([], r[commit_sha].parents)
-        self.assertTrue(b"refs/heads/new_branch" in r)
+        self.assertIn(b"refs/heads/new_branch", r)
 
         new_branch_head = commit_sha
 

dulwich/tests/test_server.py

@@ -148,7 +148,7 @@ class HandlerTestCase(TestCase):
 
         # ignore innocuous but unknown capabilities
         self.assertRaises(GitProtocolError, set_caps, [b"cap2", b"ignoreme"])
-        self.assertFalse(b"ignoreme" in self._handler.capabilities())
+        self.assertNotIn(b"ignoreme", self._handler.capabilities())
         self._handler.innocuous_capabilities = lambda: (b"ignoreme",)
         self.assertSucceeds(set_caps, [b"cap2", b"ignoreme"])
 

dulwich/tests/test_utils.py

@@ -43,20 +43,20 @@ class BuildCommitGraphTest(TestCase):
     def test_linear(self):
         c1, c2 = build_commit_graph(self.store, [[1], [2, 1]])
         for obj_id in [c1.id, c2.id, c1.tree, c2.tree]:
-            self.assertTrue(obj_id in self.store)
+            self.assertIn(obj_id, self.store)
         self.assertEqual([], c1.parents)
         self.assertEqual([c1.id], c2.parents)
         self.assertEqual(c1.tree, c2.tree)
         self.assertEqual([], self.store[c1.tree].items())
-        self.assertTrue(c2.commit_time > c1.commit_time)
+        self.assertGreater(c2.commit_time, c1.commit_time)
 
     def test_merge(self):
         c1, c2, c3, c4 = build_commit_graph(
             self.store, [[1], [2, 1], [3, 1], [4, 2, 3]]
         )
         self.assertEqual([c2.id, c3.id], c4.parents)
-        self.assertTrue(c4.commit_time > c2.commit_time)
-        self.assertTrue(c4.commit_time > c3.commit_time)
+        self.assertGreater(c4.commit_time, c2.commit_time)
+        self.assertGreater(c4.commit_time, c3.commit_time)
 
     def test_missing_parent(self):
         self.assertRaises(

dulwich/tests/test_web.py

@@ -131,7 +131,7 @@ class WebTestCase(TestCase):
         return None
 
     def assertContentTypeEquals(self, expected):
-        self.assertTrue(("Content-Type", expected) in self._headers)
+        self.assertIn(("Content-Type", expected), self._headers)
 
 
 def _test_backend(objects, refs=None, named_files=None):
@@ -355,7 +355,7 @@ class SmartHandlersTestCase(WebTestCase):
         mat = re.search(".*", "/git-evil-handler")
         content = list(handle_service_request(self._req, "backend", mat))
         self.assertEqual(HTTP_FORBIDDEN, self._status)
-        self.assertFalse(b"git-evil-handler" in b"".join(content))
+        self.assertNotIn(b"git-evil-handler", b"".join(content))
         self.assertFalse(self._req.cached)
 
     def _run_handle_service_request(self, content_length=None):
@@ -396,7 +396,7 @@ class SmartHandlersTestCase(WebTestCase):
 
         mat = re.search(".*", "/git-evil-pack")
         content = list(get_info_refs(self._req, Backend(), mat))
-        self.assertFalse(b"git-evil-handler" in b"".join(content))
+        self.assertNotIn(b"git-evil-handler", b"".join(content))
         self.assertEqual(HTTP_FORBIDDEN, self._status)
         self.assertFalse(self._req.cached)