# We can test part of the module without zlib.

try:

    import zlib

except ImportError:

    zlib = None

import zipfile, os, unittest, sys, shutil

from StringIO import StringIO

from tempfile import TemporaryFile

from test.test_support import TESTFN, run_unittest

TESTFN2 = TESTFN + "2"

class TestsWithSourceFile(unittest.TestCase):

    def setUp(self):

        line_gen = ("Test of zipfile line %d." % i for i in range(0, 1000))

        self.data = '\n'.join(line_gen)

        # Make a source file with some lines

        fp = open(TESTFN, "wb")

        fp.write(self.data)

        fp.close()

    def zipTest(self, f, compression):

        # Create the ZIP archive

        zipfp = zipfile.ZipFile(f, "w", compression)

        zipfp.write(TESTFN, "another"+os.extsep+"name")

        zipfp.write(TESTFN, TESTFN)

        zipfp.writestr("strfile", self.data)

        zipfp.close()

        # Read the ZIP archive

        zipfp = zipfile.ZipFile(f, "r", compression)

        self.assertEqual(zipfp.read(TESTFN), self.data)

        self.assertEqual(zipfp.read("another"+os.extsep+"name"), self.data)

        self.assertEqual(zipfp.read("strfile"), self.data)

        # Print the ZIP directory

        fp = StringIO()

        stdout = sys.stdout

        try:

            sys.stdout = fp

            zipfp.printdir()

        finally:

            sys.stdout = stdout

        directory = fp.getvalue()

        lines = directory.splitlines()

        self.assertEquals(len(lines), 4) # Number of files + header

        self.assert_('File Name' in lines[0])

        self.assert_('Modified' in lines[0])

        self.assert_('Size' in lines[0])

        fn, date, time, size = lines[1].split()

        self.assertEquals(fn, 'another.name')

        # XXX: timestamp is not tested

        self.assertEquals(size, str(len(self.data)))

        # Check the namelist

        names = zipfp.namelist()

        self.assertEquals(len(names), 3)

        self.assert_(TESTFN in names)

        self.assert_("another"+os.extsep+"name" in names)

        self.assert_("strfile" in names)

        # Check infolist

        infos = zipfp.infolist()

        names = [ i.filename for i in infos ]

        self.assertEquals(len(names), 3)

        self.assert_(TESTFN in names)

        self.assert_("another"+os.extsep+"name" in names)

        self.assert_("strfile" in names)

        for i in infos:

            self.assertEquals(i.file_size, len(self.data))

        # check getinfo

        for nm in (TESTFN, "another"+os.extsep+"name", "strfile"):

            info = zipfp.getinfo(nm)

            self.assertEquals(info.filename, nm)

            self.assertEquals(info.file_size, len(self.data))

        # Check that testzip doesn't raise an exception

        zipfp.testzip()

        zipfp.close()

    def testStored(self):

        for f in (TESTFN2, TemporaryFile(), StringIO()):

            self.zipTest(f, zipfile.ZIP_STORED)

    if zlib:

        def testDeflated(self):

            for f in (TESTFN2, TemporaryFile(), StringIO()):

                self.zipTest(f, zipfile.ZIP_DEFLATED)

    def testAbsoluteArcnames(self):

        zipfp = zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED)

        zipfp.write(TESTFN, "/absolute")

        zipfp.close()

        zipfp = zipfile.ZipFile(TESTFN2, "r", zipfile.ZIP_STORED)

        self.assertEqual(zipfp.namelist(), ["absolute"])

        zipfp.close()

    def tearDown(self):

        os.remove(TESTFN)

        os.remove(TESTFN2)

class TestZip64InSmallFiles(unittest.TestCase):

    # These tests test the ZIP64 functionality without using large files,

    # see test_zipfile64 for proper tests.

    def setUp(self):

        self._limit = zipfile.ZIP64_LIMIT

        zipfile.ZIP64_LIMIT = 5

        line_gen = ("Test of zipfile line %d." % i for i in range(0, 1000))

        self.data = '\n'.join(line_gen)

        # Make a source file with some lines

        fp = open(TESTFN, "wb")

        fp.write(self.data)

        fp.close()

    def largeFileExceptionTest(self, f, compression):

        zipfp = zipfile.ZipFile(f, "w", compression)

        self.assertRaises(zipfile.LargeZipFile,

                zipfp.write, TESTFN, "another"+os.extsep+"name")

        zipfp.close()

    def largeFileExceptionTest2(self, f, compression):

        zipfp = zipfile.ZipFile(f, "w", compression)

        self.assertRaises(zipfile.LargeZipFile,

                zipfp.writestr, "another"+os.extsep+"name", self.data)

        zipfp.close()

    def testLargeFileException(self):

        for f in (TESTFN2, TemporaryFile(), StringIO()):

            self.largeFileExceptionTest(f, zipfile.ZIP_STORED)

            self.largeFileExceptionTest2(f, zipfile.ZIP_STORED)

    def zipTest(self, f, compression):

        # Create the ZIP archive

        zipfp = zipfile.ZipFile(f, "w", compression, allowZip64=True)

        zipfp.write(TESTFN, "another"+os.extsep+"name")

        zipfp.write(TESTFN, TESTFN)

        zipfp.writestr("strfile", self.data)

        zipfp.close()

        # Read the ZIP archive

        zipfp = zipfile.ZipFile(f, "r", compression)

        self.assertEqual(zipfp.read(TESTFN), self.data)

        self.assertEqual(zipfp.read("another"+os.extsep+"name"), self.data)

        self.assertEqual(zipfp.read("strfile"), self.data)

        # Print the ZIP directory

        fp = StringIO()

        stdout = sys.stdout

        try:

            sys.stdout = fp

            zipfp.printdir()

        finally:

            sys.stdout = stdout

        directory = fp.getvalue()

        lines = directory.splitlines()

        self.assertEquals(len(lines), 4) # Number of files + header

        self.assert_('File Name' in lines[0])

        self.assert_('Modified' in lines[0])

        self.assert_('Size' in lines[0])

        fn, date, time, size = lines[1].split()

        self.assertEquals(fn, 'another.name')

        # XXX: timestamp is not tested

        self.assertEquals(size, str(len(self.data)))

        # Check the namelist

        names = zipfp.namelist()

        self.assertEquals(len(names), 3)

        self.assert_(TESTFN in names)

        self.assert_("another"+os.extsep+"name" in names)

        self.assert_("strfile" in names)

        # Check infolist

        infos = zipfp.infolist()

        names = [ i.filename for i in infos ]

        self.assertEquals(len(names), 3)

        self.assert_(TESTFN in names)

        self.assert_("another"+os.extsep+"name" in names)

        self.assert_("strfile" in names)

        for i in infos:

            self.assertEquals(i.file_size, len(self.data))

        # check getinfo

        for nm in (TESTFN, "another"+os.extsep+"name", "strfile"):

            info = zipfp.getinfo(nm)

            self.assertEquals(info.filename, nm)

            self.assertEquals(info.file_size, len(self.data))

        # Check that testzip doesn't raise an exception

        zipfp.testzip()

        zipfp.close()

    def testStored(self):

        for f in (TESTFN2, TemporaryFile(), StringIO()):

            self.zipTest(f, zipfile.ZIP_STORED)

    if zlib:

        def testDeflated(self):

            for f in (TESTFN2, TemporaryFile(), StringIO()):

                self.zipTest(f, zipfile.ZIP_DEFLATED)

    def testAbsoluteArcnames(self):

        zipfp = zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED, allowZip64=True)

        zipfp.write(TESTFN, "/absolute")

        zipfp.close()

        zipfp = zipfile.ZipFile(TESTFN2, "r", zipfile.ZIP_STORED)

        self.assertEqual(zipfp.namelist(), ["absolute"])

        zipfp.close()

    def tearDown(self):

        zipfile.ZIP64_LIMIT = self._limit

        os.remove(TESTFN)

        os.remove(TESTFN2)

class PyZipFileTests(unittest.TestCase):

    def testWritePyfile(self):

        zipfp  = zipfile.PyZipFile(TemporaryFile(), "w")

        fn = __file__

        if fn.endswith('.pyc') or fn.endswith('.pyo'):

            fn = fn[:-1]

        zipfp.writepy(fn)

        bn = os.path.basename(fn)

        self.assert_(bn not in zipfp.namelist())

        self.assert_(bn + 'o' in zipfp.namelist() or bn + 'c' in zipfp.namelist())

        zipfp.close()

        zipfp  = zipfile.PyZipFile(TemporaryFile(), "w")

        fn = __file__

        if fn.endswith('.pyc') or fn.endswith('.pyo'):

            fn = fn[:-1]

        zipfp.writepy(fn, "testpackage")

        bn = "%s/%s"%("testpackage", os.path.basename(fn))

        self.assert_(bn not in zipfp.namelist())

        self.assert_(bn + 'o' in zipfp.namelist() or bn + 'c' in zipfp.namelist())

        zipfp.close()

    def testWritePythonPackage(self):

        import email

        packagedir = os.path.dirname(email.__file__)

        zipfp  = zipfile.PyZipFile(TemporaryFile(), "w")

        zipfp.writepy(packagedir)

        # Check for a couple of modules at different levels of the hieararchy

        names = zipfp.namelist()

        self.assert_('email/__init__.pyo' in names or 'email/__init__.pyc' in names)

        self.assert_('email/mime/text.pyo' in names or 'email/mime/text.pyc' in names)

    def testWritePythonDirectory(self):

        os.mkdir(TESTFN2)

        try:

            fp = open(os.path.join(TESTFN2, "mod1.py"), "w")

            fp.write("print 42\n")

            fp.close()

            fp = open(os.path.join(TESTFN2, "mod2.py"), "w")

            fp.write("print 42 * 42\n")

            fp.close()

            fp = open(os.path.join(TESTFN2, "mod2.txt"), "w")

            fp.write("bla bla bla\n")

            fp.close()

            zipfp  = zipfile.PyZipFile(TemporaryFile(), "w")

            zipfp.writepy(TESTFN2)

            names = zipfp.namelist()

            self.assert_('mod1.pyc' in names or 'mod1.pyo' in names)

            self.assert_('mod2.pyc' in names or 'mod2.pyo' in names)

            self.assert_('mod2.txt' not in names)

        finally:

            shutil.rmtree(TESTFN2)

class OtherTests(unittest.TestCase):

    def testCloseErroneousFile(self):

        # This test checks that the ZipFile constructor closes the file object

        # it opens if there's an error in the file.  If it doesn't, the traceback

        # holds a reference to the ZipFile object and, indirectly, the file object.

        # On Windows, this causes the os.unlink() call to fail because the

        # underlying file is still open.  This is SF bug #412214.

        #

        fp = open(TESTFN, "w")

        fp.write("this is not a legal zip file\n")

        fp.close()

        try:

            zf = zipfile.ZipFile(TESTFN)

        except zipfile.BadZipfile:

            os.unlink(TESTFN)

    def testNonExistentFileRaisesIOError(self):

        # make sure we don't raise an AttributeError when a partially-constructed

        # ZipFile instance is finalized; this tests for regression on SF tracker

        # bug #403871.

        # The bug we're testing for caused an AttributeError to be raised

        # when a ZipFile instance was created for a file that did not

        # exist; the .fp member was not initialized but was needed by the

        # __del__() method.  Since the AttributeError is in the __del__(),

        # it is ignored, but the user should be sufficiently annoyed by

        # the message on the output that regression will be noticed

        # quickly.

        self.assertRaises(IOError, zipfile.ZipFile, TESTFN)

    def testClosedZipRaisesRuntimeError(self):

        # Verify that testzip() doesn't swallow inappropriate exceptions.

        data = StringIO()

        zipf = zipfile.ZipFile(data, mode="w")

        zipf.writestr("foo.txt", "O, for a Muse of Fire!")

        zipf.close()

        # This is correct; calling .read on a closed ZipFile should throw

        # a RuntimeError, and so should calling .testzip.  An earlier

        # version of .testzip would swallow this exception (and any other)

        # and report that the first file in the archive was corrupt.

        self.assertRaises(RuntimeError, zipf.testzip)

def test_main():

    run_unittest(TestsWithSourceFile, TestZip64InSmallFiles, OtherTests, PyZipFileTests)

    #run_unittest(TestZip64InSmallFiles)

if __name__ == "__main__":

    test_main()