# Copyright (C) 2009, 2010, 2011, 2016 Canonical Ltd
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

"""Tests for breezy.export."""

import gzip
import os
import tarfile
import time
import zipfile
from io import BytesIO

from .. import errors, export, tests
from ..archive.tar import tarball_generator
from ..export import get_root_name
from . import features


class TestDirExport(tests.TestCaseWithTransport):

    def test_missing_file(self):
        self.build_tree(['a/', 'a/b', 'a/c'])
        wt = self.make_branch_and_tree('.')
        wt.add(['a', 'a/b', 'a/c'])
        os.unlink('a/c')
        export.export(wt, 'target', format="dir")
        self.assertPathExists('target/a/b')
        self.assertPathDoesNotExist('target/a/c')

    def test_empty(self):
        wt = self.make_branch_and_tree('.')
        export.export(wt, 'target', format="dir")
        self.assertEqual([], os.listdir("target"))

    def test_symlink(self):
        self.requireFeature(features.SymlinkFeature(self.test_dir))
        wt = self.make_branch_and_tree('.')
        os.symlink('source', 'link')
        wt.add(['link'])
        export.export(wt, 'target', format="dir")
        self.assertPathExists('target/link')

    def test_nested_tree(self):
        wt = self.make_branch_and_tree('.', format='development-subtree')
        subtree = self.make_branch_and_tree('subtree')
        self.build_tree(['subtree/file'])
        subtree.add(['file'])
        wt.add(['subtree'])
        export.export(wt, 'target', format="dir")
        self.assertPathExists('target/subtree')
        # TODO(jelmer): Once iter_entries_by_dir supports nested tree iteration:
        # self.assertPathExists('target/subtree/file')

    def test_to_existing_empty_dir_success(self):
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
        wt = self.make_branch_and_tree('source')
        wt.add(['a', 'b', 'b/c'])
        wt.commit('1')
        self.build_tree(['target/'])
        export.export(wt, 'target', format="dir")
        self.assertPathExists('target/a')
        self.assertPathExists('target/b')
        self.assertPathExists('target/b/c')

    def test_empty_subdir(self):
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
        wt = self.make_branch_and_tree('source')
        wt.add(['a', 'b', 'b/c'])
        wt.commit('1')
        self.build_tree(['target/'])
        export.export(wt, 'target', format="dir", subdir='')
        self.assertPathExists('target/a')
        self.assertPathExists('target/b')
        self.assertPathExists('target/b/c')

    def test_to_existing_nonempty_dir_fail(self):
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
        wt = self.make_branch_and_tree('source')
        wt.add(['a', 'b', 'b/c'])
        wt.commit('1')
        self.build_tree(['target/', 'target/foo'])
        self.assertRaises(errors.BzrError,
                          export.export, wt, 'target', format="dir")

    def test_existing_single_file(self):
        self.build_tree([
            'dir1/', 'dir1/dir2/', 'dir1/first', 'dir1/dir2/second'])
        wtree = self.make_branch_and_tree('dir1')
        wtree.add(['dir2', 'first', 'dir2/second'])
        wtree.commit('1')
        export.export(wtree, 'target1', format='dir', subdir='first')
        self.assertPathExists('target1/first')
        export.export(wtree, 'target2', format='dir', subdir='dir2/second')
        self.assertPathExists('target2/second')

    def test_files_same_timestamp(self):
        builder = self.make_branch_builder('source')
        builder.start_series()
        builder.build_snapshot(None, [
            ('add', ('', b'root-id', 'directory', '')),
            ('add', ('a', b'a-id', 'file', b'content\n'))])
        builder.build_snapshot(None, [
            ('add', ('b', b'b-id', 'file', b'content\n'))])
        builder.finish_series()
        b = builder.get_branch()
        b.lock_read()
        self.addCleanup(b.unlock)
        tree = b.basis_tree()
        orig_iter_files_bytes = tree.iter_files_bytes

        # Make iter_files_bytes slower, so we provoke mtime skew
        def iter_files_bytes(to_fetch):
            for thing in orig_iter_files_bytes(to_fetch):
                yield thing
                time.sleep(1)
        tree.iter_files_bytes = iter_files_bytes
        export.export(tree, 'target', format='dir')
        t = self.get_transport('target')
        st_a = t.stat('a')
        st_b = t.stat('b')
        # All files must be given the same mtime.
        self.assertEqual(st_a.st_mtime, st_b.st_mtime)

    def test_files_per_file_timestamps(self):
        builder = self.make_branch_builder('source')
        builder.start_series()
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
        a_time = time.mktime((1999, 12, 12, 0, 0, 0, 0, 0, 0))
        b_time = time.mktime((1980, 0o1, 0o1, 0, 0, 0, 0, 0, 0))
        builder.build_snapshot(None, [
            ('add', ('', b'root-id', 'directory', '')),
            ('add', ('a', b'a-id', 'file', b'content\n'))],
            timestamp=a_time)
        builder.build_snapshot(None, [
            ('add', ('b', b'b-id', 'file', b'content\n'))],
            timestamp=b_time)
        builder.finish_series()
        b = builder.get_branch()
        b.lock_read()
        self.addCleanup(b.unlock)
        tree = b.basis_tree()
        export.export(tree, 'target', format='dir', per_file_timestamps=True)
        t = self.get_transport('target')
        self.assertEqual(a_time, t.stat('a').st_mtime)
        self.assertEqual(b_time, t.stat('b').st_mtime)

    def test_subdir_files_per_timestamps(self):
        builder = self.make_branch_builder('source')
        builder.start_series()
        foo_time = time.mktime((1999, 12, 12, 0, 0, 0, 0, 0, 0))
        builder.build_snapshot(None, [
            ('add', ('', b'root-id', 'directory', '')),
            ('add', ('subdir', b'subdir-id', 'directory', '')),
            ('add', ('subdir/foo.txt', b'foo-id', 'file', b'content\n'))],
            timestamp=foo_time)
        builder.finish_series()
        b = builder.get_branch()
        b.lock_read()
        self.addCleanup(b.unlock)
        tree = b.basis_tree()
        export.export(tree, 'target', format='dir', subdir='subdir',
                      per_file_timestamps=True)
        t = self.get_transport('target')
        self.assertEqual(foo_time, t.stat('foo.txt').st_mtime)


class TarExporterTests(tests.TestCaseWithTransport):

    def test_xz(self):
        self.requireFeature(features.lzma)
        import lzma
        wt = self.make_branch_and_tree('.')
        self.build_tree(['a'])
        wt.add(["a"])
        wt.commit("1")
        export.export(wt, 'target.tar.xz', format="txz")
        tf = tarfile.open(fileobj=lzma.LZMAFile('target.tar.xz'))
        self.assertEqual(["target/a"], tf.getnames())

    def test_lzma(self):
        self.requireFeature(features.lzma)
        import lzma
        wt = self.make_branch_and_tree('.')
        self.build_tree(['a'])
        wt.add(["a"])
        wt.commit("1")
        export.export(wt, 'target.tar.lzma', format="tlzma")
        tf = tarfile.open(fileobj=lzma.LZMAFile('target.tar.lzma'))
        self.assertEqual(["target/a"], tf.getnames())

    def test_tgz(self):
        wt = self.make_branch_and_tree('.')
        self.build_tree(['a'])
        wt.add(["a"])
        wt.commit("1")
        export.export(wt, 'target.tar.gz', format="tgz")
        tf = tarfile.open('target.tar.gz')
        self.assertEqual(["target/a"], tf.getnames())

    def test_tgz_consistent_mtime(self):
        wt = self.make_branch_and_tree('.')
        self.build_tree(['a'])
        wt.add(["a"])
        timestamp = 1547400500
        revid = wt.commit("1", timestamp=timestamp)
        revtree = wt.branch.repository.revision_tree(revid)
        export.export(revtree, 'target.tar.gz', format="tgz")
        with gzip.GzipFile('target.tar.gz', 'r') as f:
            f.read()
            self.assertEqual(int(f.mtime), timestamp)

    def test_tgz_ignores_dest_path(self):
        # The target path should not be a part of the target file.
        # (bug #102234)
        wt = self.make_branch_and_tree('.')
        self.build_tree(['a'])
        wt.add(["a"])
        wt.commit("1")
        os.mkdir("testdir1")
        os.mkdir("testdir2")
        export.export(wt, 'testdir1/target.tar.gz', format="tgz",
                      per_file_timestamps=True)
        export.export(wt, 'testdir2/target.tar.gz', format="tgz",
                      per_file_timestamps=True)
        file1 = open('testdir1/target.tar.gz', 'rb')
        self.addCleanup(file1.close)
        file2 = open('testdir1/target.tar.gz', 'rb')
        self.addCleanup(file2.close)
        content1 = file1.read()
        content2 = file2.read()
        self.assertEqualDiff(content1, content2)
        # the gzip module doesn't have a way to read back to the original
        # filename, but it's stored as-is in the tarfile.
        self.assertFalse(b"testdir1" in content1)
        self.assertFalse(b"target.tar.gz" in content1)
        self.assertTrue(b"target.tar" in content1)

    def test_tbz2(self):
        wt = self.make_branch_and_tree('.')
        self.build_tree(['a'])
        wt.add(["a"])
        wt.commit("1")
        export.export(wt, 'target.tar.bz2', format="tbz2")
        tf = tarfile.open('target.tar.bz2')
        self.assertEqual(["target/a"], tf.getnames())

    def test_export_tarball_generator(self):
        wt = self.make_branch_and_tree('.')
        self.build_tree(['a'])
        wt.add(["a"])
        wt.commit("1", timestamp=42)
        target = BytesIO()
        with wt.lock_read():
            target.writelines(tarball_generator(wt, "bar"))
        # Ball should now be closed.
        target.seek(0)
        ball2 = tarfile.open(None, "r", target)
        self.addCleanup(ball2.close)
        self.assertEqual(["bar/a"], ball2.getnames())


class ZipExporterTests(tests.TestCaseWithTransport):

    def test_per_file_timestamps(self):
        tree = self.make_branch_and_tree('.')
        self.build_tree_contents([('har', b'foo')])
        tree.add('har')
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
        timestamp = 347151600
        tree.commit('setup', timestamp=timestamp)
        export.export(tree.basis_tree(), 'test.zip', format='zip',
                      per_file_timestamps=True)
        zfile = zipfile.ZipFile('test.zip')
        info = zfile.getinfo("test/har")
        self.assertEqual(time.localtime(timestamp)[:6], info.date_time)


class RootNameTests(tests.TestCase):

    def test_root_name(self):
        self.assertEqual('mytest', get_root_name('../mytest.tar'))
        self.assertEqual('mytar', get_root_name('mytar.tar'))
        self.assertEqual('mytar', get_root_name('mytar.tar.bz2'))
        self.assertEqual('tar.tar.tar', get_root_name('tar.tar.tar.tgz'))
        self.assertEqual('bzr-0.0.5', get_root_name('bzr-0.0.5.tar.gz'))
        self.assertEqual('bzr-0.0.5', get_root_name('bzr-0.0.5.zip'))
        self.assertEqual('bzr-0.0.5', get_root_name('bzr-0.0.5'))
        self.assertEqual('mytar', get_root_name('a/long/path/mytar.tgz'))
        self.assertEqual('other',
                         get_root_name('../parent/../dir/other.tbz2'))
        self.assertEqual('', get_root_name('-'))
