tools/mini_tar/mini_tar_test.py

# Lint as: python3
# Copyright 2022 The Bazel Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Testing for archive."""

import copy
import os
import tarfile
import unittest

from tools.mini_tar import mini_tar


class TarFileWriterTest(unittest.TestCase):
  """Testing for TarFileWriter class."""

  def assertTarFileContent(self, tar, content):
    """Assert that tarfile contains exactly the entry described by `content`.

    Args:
      tar: the path to the TAR file to test.
      content: an array describing the expected content of the TAR file. Each
               entry in that list should be a dictionary where each field is a
               field to test in the corresponding TarInfo. For testing the
               presence of a file "x", then the entry could simply be
               `{"name": "x"}`, the missing field will be ignored. To match the
               content of a file entry, use the key "data".
    """
    with tarfile.open(tar, "r:") as f:
      i = 0
      for current in f:
        error_msg = "Extraneous file at end of archive %s: %s" % (tar,
                                                                  current.name)
        self.assertLess(i, len(content), error_msg)
        for k, v in content[i].items():
          if k == "data":
            value = f.extractfile(current).read()
          else:
            value = getattr(current, k)
          error_msg = " ".join([
              "Value `%s` for key `%s` of file" % (value, k),
              "%s in archive %s does" % (current.name, tar),
              "not match expected value `%s`" % v
          ])
          self.assertEqual(value, v, error_msg)
        i += 1
      if i < len(content):
        self.fail("Missing file %s in archive %s" % (content[i], tar))

  def setUp(self):
    super(TarFileWriterTest, self).setUp()
    self.tempfile = os.path.join(os.environ["TEST_TMPDIR"], "test.tar")

  def tearDown(self):
    super(TarFileWriterTest, self).tearDown()
    if os.path.exists(self.tempfile):
      os.remove(self.tempfile)

  def test_empty_tar_file(self):
    with mini_tar.TarFileWriter(self.tempfile):
      pass
    self.assertTarFileContent(self.tempfile, [])

  def test_default_mtime_not_provided(self):
    with mini_tar.TarFileWriter(self.tempfile) as f:
      self.assertEqual(f.default_mtime, 0)

  def test_default_mtime_provided(self):
    with mini_tar.TarFileWriter(self.tempfile, default_mtime=1234) as f:
      self.assertEqual(f.default_mtime, 1234)

  def test_portable_mtime(self):
    with mini_tar.TarFileWriter(self.tempfile, default_mtime="portable") as f:
      self.assertEqual(f.default_mtime, 946684800)

  def test_files_with_dots(self):
    with mini_tar.TarFileWriter(self.tempfile) as f:
      f.add_file_and_parents("a")
      f.add_file_and_parents("b/.c")
      f.add_file_and_parents("..d")
      f.add_file_and_parents(".e")
    content = [
        {
            "name": "a"
        },
        {
            "name": "b"
        },
        {
            "name": "b/.c"
        },
        {
            "name": "..d"
        },
        {
            "name": ".e"
        },
    ]
    self.assertTarFileContent(self.tempfile, content)

  def test_add_parents(self):
    with mini_tar.TarFileWriter(self.tempfile) as f:
      f.add_parents("a/b/c/d/file")
      f.add_file_and_parents("a/b/foo")
      f.add_parents("a/b/e/file")
    content = [
        {
            "name": "a",
            "mode": 0o755
        },
        {
            "name": "a/b",
            "mode": 0o755
        },
        {
            "name": "a/b/c",
            "mode": 0o755
        },
        {
            "name": "a/b/c/d",
            "mode": 0o755
        },
        {
            "name": "a/b/foo",
            "mode": 0o644
        },
        {
            "name": "a/b/e",
            "mode": 0o755
        },
    ]
    self.assertTarFileContent(self.tempfile, content)

  def test_adding_tree(self):
    content = [
        {
            "name": "./a",
            "mode": 0o750
        },
        {
            "name": "./a/b",
            "data": b"ab",
            "mode": 0o640
        },
        {
            "name": "./a/c",
            "mode": 0o750
        },
        {
            "name": "./a/c/d",
            "data": b"acd",
            "mode": 0o640
        },
    ]
    tempdir = os.path.join(os.environ["TEST_TMPDIR"], "test_dir")
    # Iterate over the `content` array to create the directory
    # structure it describes.
    for c in content:
      if "data" in c:
        p = os.path.join(tempdir, c["name"])
        os.makedirs(os.path.dirname(p))
        with open(p, "wb") as f:
          f.write(c["data"])
    with mini_tar.TarFileWriter(self.tempfile) as f:
      f.add_file_at_dest(in_path=tempdir, dest_path=".", mode=0o640)
    self.assertTarFileContent(self.tempfile, content)

    # Try it again, but re-rooted
    with mini_tar.TarFileWriter(self.tempfile, root_directory="foo") as f:
      f.add_file_at_dest(in_path=tempdir, dest_path="x", mode=0o640)
    n_content = [
        {
            "name": "foo",
            "mode": 0o755
        },
        {
            "name": "foo/x",
            "mode": 0o750
        },
    ]
    for c in content:
      nc = copy.copy(c)
      nc["name"] = "foo/x/" + c["name"][2:]
      n_content.append(nc)
    self.assertTarFileContent(self.tempfile, n_content)


if __name__ == "__main__":
  unittest.main()