Index: Lib/test/test_tarfile.py =================================================================== --- Lib/test/test_tarfile.py (revision 78212) +++ Lib/test/test_tarfile.py (working copy) @@ -60,34 +60,33 @@ def test_fileobj_readlines(self): self.tar.extract("ustar/regtype", TEMPDIR) tarinfo = self.tar.getmember("ustar/regtype") - fobj1 = open(os.path.join(TEMPDIR, "ustar/regtype"), "rU") - fobj2 = self.tar.extractfile(tarinfo) + with open(os.path.join(TEMPDIR, "ustar/regtype"), "rU") as fobj1: + fobj2 = self.tar.extractfile(tarinfo) - lines1 = fobj1.readlines() - lines2 = fobj2.readlines() - self.assertTrue(lines1 == lines2, - "fileobj.readlines() failed") - self.assertTrue(len(lines2) == 114, - "fileobj.readlines() failed") - self.assertTrue(lines2[83] == \ - "I will gladly admit that Python is not the fastest running scripting language.\n", - "fileobj.readlines() failed") + lines1 = fobj1.readlines() + lines2 = fobj2.readlines() + self.assertTrue(lines1 == lines2, + "fileobj.readlines() failed") + self.assertTrue(len(lines2) == 114, + "fileobj.readlines() failed") + self.assertTrue(lines2[83] == \ + "I will gladly admit that Python is not the fastest running scripting language.\n", + "fileobj.readlines() failed") def test_fileobj_iter(self): self.tar.extract("ustar/regtype", TEMPDIR) tarinfo = self.tar.getmember("ustar/regtype") - fobj1 = open(os.path.join(TEMPDIR, "ustar/regtype"), "rU") - fobj2 = self.tar.extractfile(tarinfo) - lines1 = fobj1.readlines() - lines2 = [line for line in fobj2] - self.assertTrue(lines1 == lines2, - "fileobj.__iter__() failed") + with open(os.path.join(TEMPDIR, "ustar/regtype"), "rU") as fobj1: + fobj2 = self.tar.extractfile(tarinfo) + lines1 = fobj1.readlines() + lines2 = [line for line in fobj2] + self.assertTrue(lines1 == lines2, + "fileobj.__iter__() failed") def test_fileobj_seek(self): self.tar.extract("ustar/regtype", TEMPDIR) - fobj = open(os.path.join(TEMPDIR, "ustar/regtype"), "rb") - data = fobj.read() - fobj.close() + with open(os.path.join(TEMPDIR, "ustar/regtype"), "rb") as fobj: + data = fobj.read() tarinfo = self.tar.getmember("ustar/regtype") fobj = self.tar.extractfile(tarinfo) @@ -143,12 +142,12 @@ # archive successfully. Note that an empty tar archive is not the # same as an empty file! tarfile.open(tmpname, self.mode.replace("r", "w")).close() - try: - tar = tarfile.open(tmpname, self.mode) - tar.getnames() - except tarfile.ReadError: - self.fail("tarfile.open() failed on empty archive") - self.assertListEqual(tar.getmembers(), []) + with tarfile.open(tmpname, self.mode) as tar: + try: + tar.getnames() + except tarfile.ReadError: + self.fail("tarfile.open() failed on empty archive") + self.assertListEqual(tar.getmembers(), []) def test_null_tarfile(self): # Test for issue6123: Allow opening empty archives. @@ -175,43 +174,41 @@ fobj.write(tarfile.TarInfo("foo").tobuf()) fobj.close() - tar = tarfile.open(tmpname, mode="r", ignore_zeros=True) - self.assertListEqual(tar.getnames(), ["foo"], + with tarfile.open(tmpname, mode="r", ignore_zeros=True) as tar: + self.assertListEqual(tar.getnames(), ["foo"], "ignore_zeros=True should have skipped the %r-blocks" % char) - tar.close() class MiscReadTest(CommonReadTest): def test_no_name_argument(self): - fobj = open(self.tarname, "rb") - tar = tarfile.open(fileobj=fobj, mode=self.mode) - self.assertEqual(tar.name, os.path.abspath(fobj.name)) + with open(self.tarname, "rb") as fobj: + with tarfile.open(fileobj=fobj, mode=self.mode) as tar: + self.assertEqual(tar.name, os.path.abspath(fobj.name)) def test_no_name_attribute(self): data = open(self.tarname, "rb").read() fobj = StringIO.StringIO(data) self.assertRaises(AttributeError, getattr, fobj, "name") - tar = tarfile.open(fileobj=fobj, mode=self.mode) - self.assertEqual(tar.name, None) + with tarfile.open(fileobj=fobj, mode=self.mode) as tar: + self.assertEqual(tar.name, None) def test_empty_name_attribute(self): data = open(self.tarname, "rb").read() fobj = StringIO.StringIO(data) fobj.name = "" - tar = tarfile.open(fileobj=fobj, mode=self.mode) - self.assertEqual(tar.name, None) + with tarfile.open(fileobj=fobj, mode=self.mode) as tar: + self.assertEqual(tar.name, None) def test_fileobj_with_offset(self): # Skip the first member and store values from the second member # of the testtar. - tar = tarfile.open(self.tarname, mode=self.mode) - tar.next() - t = tar.next() - name = t.name - offset = t.offset - data = tar.extractfile(t).read() - tar.close() + with tarfile.open(self.tarname, mode=self.mode) as tar: + tar.next() + t = tar.next() + name = t.name + offset = t.offset + data = tar.extractfile(t).read() # Open the testtar and seek to the offset of the second member. if self.mode.endswith(":gz"): @@ -224,15 +221,14 @@ fobj.seek(offset) # Test if the tarfile starts with the second member. - tar = tar.open(self.tarname, mode="r:", fileobj=fobj) - t = tar.next() - self.assertEqual(t.name, name) - # Read to the end of fileobj and test if seeking back to the - # beginning works. - tar.getmembers() - self.assertEqual(tar.extractfile(t).read(), data, - "seek back did not work") - tar.close() + with tar.open(self.tarname, mode="r:", fileobj=fobj) as tar: + t = tar.next() + self.assertEqual(t.name, name) + # Read to the end of fileobj and test if seeking back to the + # beginning works. + tar.getmembers() + self.assertEqual(tar.extractfile(t).read(), data, + "seek back did not work") def test_fail_comp(self): # For Gzip and Bz2 Tests: fail with a ReadError on an uncompressed file. @@ -240,7 +236,11 @@ return self.assertRaises(tarfile.ReadError, tarfile.open, tarname, self.mode) fobj = open(tarname, "rb") - self.assertRaises(tarfile.ReadError, tarfile.open, fileobj=fobj, mode=self.mode) + try: + self.assertRaises(tarfile.ReadError, tarfile.open, fileobj=fobj, + mode=self.mode) + finally: + fobj.close() def test_v7_dirtype(self): # Test old style dirtype member (bug #1336623): @@ -274,40 +274,38 @@ def test_extract_hardlink(self): # Test hardlink extraction (e.g. bug #857297). - tar = tarfile.open(tarname, errorlevel=1, encoding="iso8859-1") + with tarfile.open(tarname, errorlevel=1, encoding="iso8859-1") as tar: + tar.extract("ustar/regtype", TEMPDIR) + try: + tar.extract("ustar/lnktype", TEMPDIR) + except EnvironmentError, e: + if e.errno == errno.ENOENT: + self.fail("hardlink not extracted properly") - tar.extract("ustar/regtype", TEMPDIR) - try: - tar.extract("ustar/lnktype", TEMPDIR) - except EnvironmentError, e: - if e.errno == errno.ENOENT: - self.fail("hardlink not extracted properly") + data = open(os.path.join(TEMPDIR, "ustar/lnktype"), "rb").read() + self.assertEqual(md5sum(data), md5_regtype) - data = open(os.path.join(TEMPDIR, "ustar/lnktype"), "rb").read() - self.assertEqual(md5sum(data), md5_regtype) + try: + tar.extract("ustar/symtype", TEMPDIR) + except EnvironmentError, e: + if e.errno == errno.ENOENT: + self.fail("symlink not extracted properly") - try: - tar.extract("ustar/symtype", TEMPDIR) - except EnvironmentError, e: - if e.errno == errno.ENOENT: - self.fail("symlink not extracted properly") + data = open(os.path.join(TEMPDIR, "ustar/symtype"), "rb").read() + self.assertEqual(md5sum(data), md5_regtype) - data = open(os.path.join(TEMPDIR, "ustar/symtype"), "rb").read() - self.assertEqual(md5sum(data), md5_regtype) - def test_extractall(self): # Test if extractall() correctly restores directory permissions # and times (see issue1735). - tar = tarfile.open(tarname, encoding="iso8859-1") - directories = [t for t in tar if t.isdir()] - tar.extractall(TEMPDIR, directories) - for tarinfo in directories: - path = os.path.join(TEMPDIR, tarinfo.name) - if sys.platform != "win32": - # Win32 has no support for fine grained permissions. - self.assertEqual(tarinfo.mode & 0777, os.stat(path).st_mode & 0777) - self.assertEqual(tarinfo.mtime, os.path.getmtime(path)) - tar.close() + with tarfile.open(tarname, encoding="iso8859-1") as tar: + directories = [t for t in tar if t.isdir()] + tar.extractall(TEMPDIR, directories) + for tarinfo in directories: + path = os.path.join(TEMPDIR, tarinfo.name) + if sys.platform != "win32": + # Win32 has no support for fine grained permissions. + self.assertEqual(tarinfo.mode & 0777, os.stat(path).st_mode & 0777) + self.assertEqual(tarinfo.mtime, os.path.getmtime(path)) def test_init_close_fobj(self): # Issue #7341: Close the internal file object in the TarFile @@ -345,30 +343,28 @@ self.assertRaises(tarfile.StreamError, f.read) def test_compare_members(self): - tar1 = tarfile.open(tarname, encoding="iso8859-1") - tar2 = self.tar + with tarfile.open(tarname, encoding="iso8859-1") as tar1: + tar2 = self.tar - while True: - t1 = tar1.next() - t2 = tar2.next() - if t1 is None: - break - self.assertTrue(t2 is not None, "stream.next() failed.") + while True: + t1 = tar1.next() + t2 = tar2.next() + if t1 is None: + break + self.assertTrue(t2 is not None, "stream.next() failed.") - if t2.islnk() or t2.issym(): - self.assertRaises(tarfile.StreamError, tar2.extractfile, t2) - continue + if t2.islnk() or t2.issym(): + self.assertRaises(tarfile.StreamError, tar2.extractfile, t2) + continue - v1 = tar1.extractfile(t1) - v2 = tar2.extractfile(t2) - if v1 is None: - continue - self.assertTrue(v2 is not None, "stream.extractfile() failed") - self.assertTrue(v1.read() == v2.read(), "stream extraction failed") + v1 = tar1.extractfile(t1) + v2 = tar2.extractfile(t2) + if v1 is None: + continue + self.assertTrue(v2 is not None, "stream.extractfile() failed") + self.assertTrue(v1.read() == v2.read(), "stream extraction failed") - tar1.close() - class DetectReadTest(unittest.TestCase): def _testfunc_file(self, name, mode): @@ -530,10 +526,10 @@ # the preceding extended header. longname = self.subdir + "/" + "123/" * 125 + "longname" offset = self.tar.getmember(longname).offset - fobj = open(tarname) - fobj.seek(offset) - tarinfo = tarfile.TarInfo.frombuf(fobj.read(512)) - self.assertEqual(tarinfo.type, self.longnametype) + with open(tarname) as fobj: + fobj.seek(offset) + tarinfo = tarfile.TarInfo.frombuf(fobj.read(512)) + self.assertEqual(tarinfo.type, self.longnametype) class GNUReadTest(LongnameTest): @@ -556,34 +552,36 @@ longnametype = tarfile.XHDTYPE def test_pax_global_headers(self): - tar = tarfile.open(tarname, encoding="iso8859-1") + with tarfile.open(tarname, encoding="iso8859-1") as tar: + tarinfo = tar.getmember("pax/regtype1") + self.assertEqual(tarinfo.uname, "foo") + self.assertEqual(tarinfo.gname, "bar") + self.assertEqual(tarinfo.pax_headers.get("VENDOR.umlauts"), + u"ÄÖÜäöüß") - tarinfo = tar.getmember("pax/regtype1") - self.assertEqual(tarinfo.uname, "foo") - self.assertEqual(tarinfo.gname, "bar") - self.assertEqual(tarinfo.pax_headers.get("VENDOR.umlauts"), u"ÄÖÜäöüß") + tarinfo = tar.getmember("pax/regtype2") + self.assertEqual(tarinfo.uname, "") + self.assertEqual(tarinfo.gname, "bar") + self.assertEqual(tarinfo.pax_headers.get("VENDOR.umlauts"), + u"ÄÖÜäöüß") - tarinfo = tar.getmember("pax/regtype2") - self.assertEqual(tarinfo.uname, "") - self.assertEqual(tarinfo.gname, "bar") - self.assertEqual(tarinfo.pax_headers.get("VENDOR.umlauts"), u"ÄÖÜäöüß") + tarinfo = tar.getmember("pax/regtype3") + self.assertEqual(tarinfo.uname, "tarfile") + self.assertEqual(tarinfo.gname, "tarfile") + self.assertEqual(tarinfo.pax_headers.get("VENDOR.umlauts"), + u"ÄÖÜäöüß") - tarinfo = tar.getmember("pax/regtype3") - self.assertEqual(tarinfo.uname, "tarfile") - self.assertEqual(tarinfo.gname, "tarfile") - self.assertEqual(tarinfo.pax_headers.get("VENDOR.umlauts"), u"ÄÖÜäöüß") - def test_pax_number_fields(self): # All following number fields are read from the pax header. - tar = tarfile.open(tarname, encoding="iso8859-1") - tarinfo = tar.getmember("pax/regtype4") - self.assertEqual(tarinfo.size, 7011) - self.assertEqual(tarinfo.uid, 123) - self.assertEqual(tarinfo.gid, 123) - self.assertEqual(tarinfo.mtime, 1041808783.0) - self.assertEqual(type(tarinfo.mtime), float) - self.assertEqual(float(tarinfo.pax_headers["atime"]), 1041808783.0) - self.assertEqual(float(tarinfo.pax_headers["ctime"]), 1041808783.0) + with tarfile.open(tarname, encoding="iso8859-1") as tar: + tarinfo = tar.getmember("pax/regtype4") + self.assertEqual(tarinfo.size, 7011) + self.assertEqual(tarinfo.uid, 123) + self.assertEqual(tarinfo.gid, 123) + self.assertEqual(tarinfo.mtime, 1041808783.0) + self.assertEqual(type(tarinfo.mtime), float) + self.assertEqual(float(tarinfo.pax_headers["atime"]), 1041808783.0) + self.assertEqual(float(tarinfo.pax_headers["ctime"]), 1041808783.0) class WriteTestBase(unittest.TestCase): @@ -592,9 +590,8 @@ def test_fileobj_no_close(self): fobj = StringIO.StringIO() - tar = tarfile.open(fileobj=fobj, mode=self.mode) - tar.addfile(tarfile.TarInfo("foo")) - tar.close() + with tarfile.open(fileobj=fobj, mode=self.mode) as tar: + tar.addfile(tarfile.TarInfo("foo")) self.assertTrue(fobj.closed is False, "external fileobjs must never closed") @@ -608,52 +605,44 @@ # which implies that a string of exactly 100 chars is stored without # a trailing '\0'. name = "0123456789" * 10 - tar = tarfile.open(tmpname, self.mode) - t = tarfile.TarInfo(name) - tar.addfile(t) - tar.close() + with tarfile.open(tmpname, self.mode) as tar: + t = tarfile.TarInfo(name) + tar.addfile(t) - tar = tarfile.open(tmpname) - self.assertTrue(tar.getnames()[0] == name, - "failed to store 100 char filename") - tar.close() + with tarfile.open(tmpname) as tar: + self.assertTrue(tar.getnames()[0] == name, + "failed to store 100 char filename") def test_tar_size(self): # Test for bug #1013882. - tar = tarfile.open(tmpname, self.mode) - path = os.path.join(TEMPDIR, "file") - fobj = open(path, "wb") - fobj.write("aaa") - fobj.close() - tar.add(path) - tar.close() + with tarfile.open(tmpname, self.mode) as tar: + path = os.path.join(TEMPDIR, "file") + with open(path, "wb") as fobj: + fobj.write("aaa") + tar.add(path) self.assertTrue(os.path.getsize(tmpname) > 0, "tarfile is empty") # The test_*_size tests test for bug #1167128. def test_file_size(self): - tar = tarfile.open(tmpname, self.mode) + with tarfile.open(tmpname, self.mode) as tar: + path = os.path.join(TEMPDIR, "file") + fobj = open(path, "wb") + fobj.close() + tarinfo = tar.gettarinfo(path) + self.assertEqual(tarinfo.size, 0) - path = os.path.join(TEMPDIR, "file") - fobj = open(path, "wb") - fobj.close() - tarinfo = tar.gettarinfo(path) - self.assertEqual(tarinfo.size, 0) + with open(path, "wb") as fobj: + fobj.write("aaa") + tarinfo = tar.gettarinfo(path) + self.assertEqual(tarinfo.size, 3) - fobj = open(path, "wb") - fobj.write("aaa") - fobj.close() - tarinfo = tar.gettarinfo(path) - self.assertEqual(tarinfo.size, 3) - - tar.close() - def test_directory_size(self): path = os.path.join(TEMPDIR, "directory") os.mkdir(path) try: - tar = tarfile.open(tmpname, self.mode) - tarinfo = tar.gettarinfo(path) + with tarfile.open(tmpname, self.mode) as tar: + tarinfo = tar.gettarinfo(path) self.assertEqual(tarinfo.size, 0) finally: os.rmdir(path) @@ -665,9 +654,9 @@ open(target, "wb").close() os.link(target, link) try: - tar = tarfile.open(tmpname, self.mode) - tarinfo = tar.gettarinfo(link) - self.assertEqual(tarinfo.size, 0) + with tarfile.open(tmpname, self.mode) as tar: + tarinfo = tar.gettarinfo(link) + self.assertEqual(tarinfo.size, 0) finally: os.remove(target) os.remove(link) @@ -677,9 +666,9 @@ path = os.path.join(TEMPDIR, "symlink") os.symlink("link_target", path) try: - tar = tarfile.open(tmpname, self.mode) - tarinfo = tar.gettarinfo(path) - self.assertEqual(tarinfo.size, 0) + with tarfile.open(tmpname, self.mode) as tar: + tarinfo = tar.gettarinfo(path) + self.assertEqual(tarinfo.size, 0) finally: os.remove(path) @@ -687,17 +676,20 @@ # Test for #1257255. dstname = os.path.abspath(tmpname) - tar = tarfile.open(tmpname, self.mode) - self.assertTrue(tar.name == dstname, "archive name must be absolute") + with tarfile.open(tmpname, self.mode) as tar: + self.assertTrue(tar.name == dstname, + "archive name must be absolute") - tar.add(dstname) - self.assertTrue(tar.getnames() == [], "added the archive to itself") + tar.add(dstname) + self.assertTrue(tar.getnames() == [], + "added the archive to itself") - cwd = os.getcwd() - os.chdir(TEMPDIR) - tar.add(dstname) - os.chdir(cwd) - self.assertTrue(tar.getnames() == [], "added the archive to itself") + cwd = os.getcwd() + os.chdir(TEMPDIR) + tar.add(dstname) + os.chdir(cwd) + self.assertTrue(tar.getnames() == [], + "added the archive to itself") def test_exclude(self): tempdir = os.path.join(TEMPDIR, "exclude") @@ -710,13 +702,12 @@ def exclude(name): return os.path.isfile(name) - tar = tarfile.open(tmpname, self.mode, encoding="iso8859-1") - tar.add(tempdir, arcname="empty_dir", exclude=exclude) - tar.close() + with tarfile.open(tmpname, self.mode, encoding="iso8859-1") as tar: + tar.add(tempdir, arcname="empty_dir", exclude=exclude) - tar = tarfile.open(tmpname, "r") - self.assertEqual(len(tar.getmembers()), 1) - self.assertEqual(tar.getnames()[0], "empty_dir") + with tarfile.open(tmpname, "r") as tar: + self.assertEqual(len(tar.getmembers()), 1) + self.assertEqual(tar.getnames()[0], "empty_dir") finally: shutil.rmtree(tempdir) @@ -735,16 +726,14 @@ tarinfo.uname = "foo" return tarinfo - tar = tarfile.open(tmpname, self.mode, encoding="iso8859-1") - tar.add(tempdir, arcname="empty_dir", filter=filter) - tar.close() + with tarfile.open(tmpname, self.mode, encoding="iso8859-1") as tar: + tar.add(tempdir, arcname="empty_dir", filter=filter) - tar = tarfile.open(tmpname, "r") - for tarinfo in tar: - self.assertEqual(tarinfo.uid, 123) - self.assertEqual(tarinfo.uname, "foo") - self.assertEqual(len(tar.getmembers()), 3) - tar.close() + with tarfile.open(tmpname, "r") as tar: + for tarinfo in tar: + self.assertEqual(tarinfo.uid, 123) + self.assertEqual(tarinfo.uname, "foo") + self.assertEqual(len(tar.getmembers()), 3) finally: shutil.rmtree(tempdir) @@ -761,13 +750,11 @@ else: os.mkdir(foo) - tar = tarfile.open(tmpname, self.mode) - tar.add(foo, arcname=path) - tar.close() + with tarfile.open(tmpname, self.mode) as tar: + tar.add(foo, arcname=path) - tar = tarfile.open(tmpname, "r") - t = tar.next() - tar.close() + with tarfile.open(tmpname, "r") as tar: + t = tar.next() if not dir: os.remove(foo) @@ -807,14 +794,12 @@ try: open("foo", "w").close() - tar = tarfile.open(tmpname, self.mode) - tar.add(".") - tar.close() + with tarfile.open(tmpname, self.mode) as tar: + tar.add(".") - tar = tarfile.open(tmpname, "r") - for t in tar: - self.assert_(t.name == "." or t.name.startswith("./")) - tar.close() + with tarfile.open(tmpname, "r") as tar: + for t in tar: + self.assert_(t.name == "." or t.name.startswith("./")) finally: os.chdir(cwd) @@ -829,9 +814,8 @@ tar.close() if self.mode.endswith("gz"): - fobj = gzip.GzipFile(tmpname) - data = fobj.read() - fobj.close() + with gzip.GzipFile(tmpname) as fobj: + data = fobj.read() elif self.mode.endswith("bz2"): dec = bz2.BZ2Decompressor() data = open(tmpname, "rb").read() @@ -839,9 +823,8 @@ self.assertTrue(len(dec.unused_data) == 0, "found trailing data") else: - fobj = open(tmpname, "rb") - data = fobj.read() - fobj.close() + with open(tmpname, "rb") as fobj: + data = fobj.read() self.assertTrue(data.count("\0") == tarfile.RECORDSIZE, "incorrect zero padding") @@ -877,18 +860,16 @@ tarinfo.linkname = link tarinfo.type = tarfile.LNKTYPE - tar = tarfile.open(tmpname, "w") - tar.format = tarfile.GNU_FORMAT - tar.addfile(tarinfo) + with tarfile.open(tmpname, "w") as tar: + tar.format = tarfile.GNU_FORMAT + tar.addfile(tarinfo) - v1 = self._calc_size(name, link) - v2 = tar.offset - self.assertTrue(v1 == v2, "GNU longname/longlink creation failed") + v1 = self._calc_size(name, link) + v2 = tar.offset + self.assertTrue(v1 == v2, "GNU longname/longlink creation failed") - tar.close() - - tar = tarfile.open(tmpname) - member = tar.next() + with tarfile.open(tmpname) as tar: + member = tar.next() self.assertFalse(member is None, "unable to read longname member") self.assertTrue(tarinfo.name == member.name and \ tarinfo.linkname == member.linkname, \ @@ -932,9 +913,8 @@ self.foo = os.path.join(TEMPDIR, "foo") self.bar = os.path.join(TEMPDIR, "bar") - fobj = open(self.foo, "wb") - fobj.write("foo") - fobj.close() + with open(self.foo, "wb") as fobj: + fobj.write("foo") os.link(self.foo, self.bar) @@ -974,17 +954,16 @@ tarinfo.linkname = link tarinfo.type = tarfile.LNKTYPE - tar = tarfile.open(tmpname, "w", format=tarfile.PAX_FORMAT) - tar.addfile(tarinfo) - tar.close() + with tarfile.open(tmpname, "w", format=tarfile.PAX_FORMAT) as tar: + tar.addfile(tarinfo) - tar = tarfile.open(tmpname) - if link: - l = tar.getmembers()[0].linkname - self.assertTrue(link == l, "PAX longlink creation failed") - else: - n = tar.getmembers()[0].name - self.assertTrue(name == n, "PAX longname creation failed") + with tarfile.open(tmpname) as tar: + if link: + l = tar.getmembers()[0].linkname + self.assertTrue(link == l, "PAX longlink creation failed") + else: + n = tar.getmembers()[0].name + self.assertTrue(name == n, "PAX longname creation failed") def test_pax_global_header(self): pax_headers = { @@ -994,44 +973,43 @@ u"test": u"äöü", u"äöü": u"test"} - tar = tarfile.open(tmpname, "w", format=tarfile.PAX_FORMAT, \ - pax_headers=pax_headers) - tar.addfile(tarfile.TarInfo("test")) - tar.close() + with tarfile.open(tmpname, "w", format=tarfile.PAX_FORMAT, \ + pax_headers=pax_headers) as tar: + tar.addfile(tarfile.TarInfo("test")) # Test if the global header was written correctly. - tar = tarfile.open(tmpname, encoding="iso8859-1") - self.assertEqual(tar.pax_headers, pax_headers) - self.assertEqual(tar.getmembers()[0].pax_headers, pax_headers) + with tarfile.open(tmpname, encoding="iso8859-1") as tar: + self.assertEqual(tar.pax_headers, pax_headers) + self.assertEqual(tar.getmembers()[0].pax_headers, pax_headers) - # Test if all the fields are unicode. - for key, val in tar.pax_headers.iteritems(): - self.assertTrue(type(key) is unicode) - self.assertTrue(type(val) is unicode) - if key in tarfile.PAX_NUMBER_FIELDS: - try: - tarfile.PAX_NUMBER_FIELDS[key](val) - except (TypeError, ValueError): - self.fail("unable to convert pax header field") + # Test if all the fields are unicode. + for key, val in tar.pax_headers.iteritems(): + self.assertTrue(type(key) is unicode) + self.assertTrue(type(val) is unicode) + if key in tarfile.PAX_NUMBER_FIELDS: + try: + tarfile.PAX_NUMBER_FIELDS[key](val) + except (TypeError, ValueError): + self.fail("unable to convert pax header field") def test_pax_extended_header(self): # The fields from the pax header have priority over the # TarInfo. pax_headers = {u"path": u"foo", u"uid": u"123"} - tar = tarfile.open(tmpname, "w", format=tarfile.PAX_FORMAT, encoding="iso8859-1") - t = tarfile.TarInfo() - t.name = u"äöü" # non-ASCII - t.uid = 8**8 # too large - t.pax_headers = pax_headers - tar.addfile(t) - tar.close() + with tarfile.open(tmpname, "w", format=tarfile.PAX_FORMAT, + encoding="iso8859-1") as tar: + t = tarfile.TarInfo() + t.name = u"äöü" # non-ASCII + t.uid = 8**8 # too large + t.pax_headers = pax_headers + tar.addfile(t) - tar = tarfile.open(tmpname, encoding="iso8859-1") - t = tar.getmembers()[0] - self.assertEqual(t.pax_headers, pax_headers) - self.assertEqual(t.name, "foo") - self.assertEqual(t.uid, 123) + with tarfile.open(tmpname, encoding="iso8859-1") as tar: + t = tar.getmembers()[0] + self.assertEqual(t.pax_headers, pax_headers) + self.assertEqual(t.name, "foo") + self.assertEqual(t.uid, 123) class UstarUnicodeTest(unittest.TestCase): @@ -1049,41 +1027,41 @@ self._test_unicode_filename("utf8") def _test_unicode_filename(self, encoding): - tar = tarfile.open(tmpname, "w", format=self.format, encoding=encoding, errors="strict") - name = u"äöü" - tar.addfile(tarfile.TarInfo(name)) - tar.close() + with tarfile.open(tmpname, "w", format=self.format, encoding=encoding, + errors="strict") as tar: + name = u"äöü" + tar.addfile(tarfile.TarInfo(name)) - tar = tarfile.open(tmpname, encoding=encoding) - self.assertTrue(type(tar.getnames()[0]) is not unicode) - self.assertEqual(tar.getmembers()[0].name, name.encode(encoding)) - tar.close() + with tarfile.open(tmpname, encoding=encoding) as tar: + self.assertTrue(type(tar.getnames()[0]) is not unicode) + self.assertEqual(tar.getmembers()[0].name, name.encode(encoding)) def test_unicode_filename_error(self): - tar = tarfile.open(tmpname, "w", format=self.format, encoding="ascii", errors="strict") - tarinfo = tarfile.TarInfo() + with tarfile.open(tmpname, "w", format=self.format, encoding="ascii", + errors="strict") as tar: + tarinfo = tarfile.TarInfo() - tarinfo.name = "äöü" - if self.format == tarfile.PAX_FORMAT: + tarinfo.name = "äöü" + if self.format == tarfile.PAX_FORMAT: + self.assertRaises(UnicodeError, tar.addfile, tarinfo) + else: + tar.addfile(tarinfo) + + tarinfo.name = u"äöü" self.assertRaises(UnicodeError, tar.addfile, tarinfo) - else: - tar.addfile(tarinfo) - tarinfo.name = u"äöü" - self.assertRaises(UnicodeError, tar.addfile, tarinfo) + tarinfo.name = "foo" + tarinfo.uname = u"äöü" + self.assertRaises(UnicodeError, tar.addfile, tarinfo) - tarinfo.name = "foo" - tarinfo.uname = u"äöü" - self.assertRaises(UnicodeError, tar.addfile, tarinfo) - def test_unicode_argument(self): - tar = tarfile.open(tarname, "r", encoding="iso8859-1", errors="strict") - for t in tar: - self.assertTrue(type(t.name) is str) - self.assertTrue(type(t.linkname) is str) - self.assertTrue(type(t.uname) is str) - self.assertTrue(type(t.gname) is str) - tar.close() + with tarfile.open(tarname, "r", encoding="iso8859-1", + errors="strict") as tar: + for t in tar: + self.assertTrue(type(t.name) is str) + self.assertTrue(type(t.linkname) is str) + self.assertTrue(type(t.uname) is str) + self.assertTrue(type(t.gname) is str) def test_uname_unicode(self): for name in (u"äöü", "äöü"): @@ -1092,15 +1070,16 @@ t.gname = name fobj = StringIO.StringIO() - tar = tarfile.open("foo.tar", mode="w", fileobj=fobj, format=self.format, encoding="iso8859-1") - tar.addfile(t) - tar.close() + with tarfile.open("foo.tar", mode="w", fileobj=fobj, + format=self.format, encoding="iso8859-1") as tar: + tar.addfile(t) fobj.seek(0) - tar = tarfile.open("foo.tar", fileobj=fobj, encoding="iso8859-1") - t = tar.getmember("foo") - self.assertEqual(t.uname, "äöü") - self.assertEqual(t.gname, "äöü") + with tarfile.open("foo.tar", fileobj=fobj, + encoding="iso8859-1") as tar: + t = tar.getmember("foo") + self.assertEqual(t.uname, "äöü") + self.assertEqual(t.gname, "äöü") class GNUUnicodeTest(UstarUnicodeTest): @@ -1113,11 +1092,10 @@ format = tarfile.PAX_FORMAT def _create_unicode_name(self, name): - tar = tarfile.open(tmpname, "w", format=self.format) - t = tarfile.TarInfo() - t.pax_headers["path"] = name - tar.addfile(t) - tar.close() + with tarfile.open(tmpname, "w", format=self.format) as tar: + t = tarfile.TarInfo() + t.pax_headers["path"] = name + tar.addfile(t) def test_error_handlers(self): # Test if the unicode error handlers work correctly for characters @@ -1126,9 +1104,9 @@ for handler, name in (("utf-8", u"äöü".encode("utf8")), ("replace", "???"), ("ignore", "")): - tar = tarfile.open(tmpname, format=self.format, encoding="ascii", - errors=handler) - self.assertEqual(tar.getnames()[0], name) + with tarfile.open(tmpname, format=self.format, encoding="ascii", + errors=handler) as tar: + self.assertEqual(tar.getnames()[0], name) self.assertRaises(UnicodeError, tarfile.open, tmpname, encoding="ascii", errors="strict") @@ -1138,9 +1116,9 @@ # iso8859-1 and the other only in iso8859-15. self._create_unicode_name(u"äöü/¤") - tar = tarfile.open(tmpname, format=self.format, encoding="iso8859-1", - errors="utf-8") - self.assertEqual(tar.getnames()[0], "äöü/" + u"¤".encode("utf8")) + with tarfile.open(tmpname, format=self.format, encoding="iso8859-1", + errors="utf-8") as tar: + self.assertEqual(tar.getnames()[0], "äöü/" + u"¤".encode("utf8")) class AppendTest(unittest.TestCase): @@ -1152,22 +1130,20 @@ os.remove(self.tarname) def _add_testfile(self, fileobj=None): - tar = tarfile.open(self.tarname, "a", fileobj=fileobj) - tar.addfile(tarfile.TarInfo("bar")) - tar.close() + with tarfile.open(self.tarname, "a", fileobj=fileobj) as tar: + tar.addfile(tarfile.TarInfo("bar")) def _create_testtar(self, mode="w:"): - src = tarfile.open(tarname, encoding="iso8859-1") - t = src.getmember("ustar/regtype") - t.name = "foo" - f = src.extractfile(t) - tar = tarfile.open(self.tarname, mode) - tar.addfile(t, f) - tar.close() + with tarfile.open(tarname, encoding="iso8859-1") as src: + t = src.getmember("ustar/regtype") + t.name = "foo" + f = src.extractfile(t) + with tarfile.open(self.tarname, mode) as tar: + tar.addfile(t, f) def _test(self, names=["bar"], fileobj=None): - tar = tarfile.open(self.tarname, fileobj=fileobj) - self.assertEqual(tar.getnames(), names) + with tarfile.open(self.tarname, fileobj=fileobj) as tar: + self.assertEqual(tar.getnames(), names) def test_non_existing(self): self._add_testfile() @@ -1376,15 +1352,13 @@ if hasattr(os, "link"): tests.append(HardlinkTest) - fobj = open(tarname, "rb") - data = fobj.read() - fobj.close() + with open(tarname, "rb") as fobj: + data = fobj.read() if gzip: # Create testtar.tar.gz and add gzip-specific tests. - tar = gzip.open(gzipname, "wb") - tar.write(data) - tar.close() + with gzip.open(gzipname, "wb") as tar: + tar.write(data) tests += [ GzipMiscReadTest,