Porting tests for zip package to dist-git

tests/tests.yml

@@ -0,0 +1,65 @@
+---
+- hosts: localhost
+  tags:
+    - classic
+
+  vars:
+    - artifacts: "{{ lookup('env', 'TEST_ARTIFACTS')|default('./artifacts', true) }}"
+
+  tasks:
+    - name: Define remote_artifacts if it is not already defined
+      set_fact:
+        remote_artifacts: /home/${USER}/artifacts
+      when: remote_artifacts is not defined
+
+    - name: Copy tests to target
+      synchronize:
+        src: "{{ playbook_dir }}/"
+        dest: /home/${USER}/bin/
+        ssh_args: "-o UserKnownHostsFile=/dev/null"
+
+    - name: Make artifacts directory
+      file: path={{ remote_artifacts }} state=directory recurse=yes
+
+    - block:
+      - name: Execute tests
+        shell: |
+          logfile={{ remote_artifacts }}/test.{{ item }}.log
+          exec 2>>$logfile 1>>$logfile
+          cd tests
+          #make script executable
+          chmod 0775 {{ item }}
+          #execute the test
+          python2 {{ item }}.py
+          if [ $? -eq 0 ]; then
+              echo "PASS {{ item }}" >> {{ remote_artifacts }}/test.log
+          else
+              echo "FAIL {{ item }}" >> {{ remote_artifacts }}/test.log
+          fi
+        with_items:
+        - "test_4GBsegfault"
+        - "test_big_file_in_archive"
+        - "test_long_path_in_archive"
+        - "test_many_files_in_archive"
+        - "test_umask"
+        - "test_umask_when_creating"
+        - "test_zipnote_fails_to_update_the_archive"
+
+
+      - name: Pull out the logs
+        synchronize:
+          dest: "{{ artifacts }}/"
+          src: "{{ remote_artifacts }}/"
+          mode: pull
+          ssh_args: "-o UserKnownHostsFile=/dev/null"
+        when: artifacts|default("") != ""
+
+      # Can't go in block. See
+      # https://github.com/ansible/ansible/issues/20736
+      - name: Check the results
+        shell: grep "^FAIL" {{ remote_artifacts }}/test.log
+        register: test_fails
+        failed_when: test_fails.stdout or test_fails.stderr
+
+
+

tests/tests/__init__.py

@@ -0,0 +1,154 @@
+'''
+    author = esakaiev@redhat.com
+'''
+import logging
+import sys
+import subprocess
+import os
+import shutil
+
+
+def decorated_message(message):
+    """
+        This decorator is used for providing logging header for different sections in the scripts
+        :param message: (`STRING`)
+        :return: decorated_function
+    """
+
+    def decorated_function(func):
+        """
+
+        :param func:
+        :return:
+        """
+
+        def wrapper(self):
+            """
+
+            :param self:
+            :return:
+            """
+            print " "
+            print ("::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            print (":: {0}".format(message))
+            print ("::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+
+            func(self)
+
+        return wrapper
+
+    return decorated_function
+
+
+class BaseZipTests(object):
+    """
+        This is a Base class for zip tests
+    """
+
+    def __init__(self):
+        self._set_logger()
+        self._purpose = ""
+        self.print_test_purpose()
+
+    def _set_logger(self):
+        """
+        This method is used for instantiating of logger
+        :return:
+        - None
+        """
+        self.logger = logging.getLogger()
+        self.logger.setLevel(logging.DEBUG)
+
+        self.handler = logging.StreamHandler(sys.stdout)
+        self.handler.setLevel(logging.DEBUG)
+        formatter = logging.Formatter('[ %(asctime)s ] :: [ %(message)s ]')
+        self.handler.setFormatter(formatter)
+        self.logger.addHandler(self.handler)
+
+    @decorated_message("PURPOSE")
+    def print_test_purpose(self):
+        """
+
+        :return:
+        """
+        print self._purpose
+
+    def run_cmd(self, cmd, exp_err_code, message, cwd=None):
+        """
+        This method is used for executing cmd, check output error code and
+        add result in the logger
+        :param cmd: ('STRING') - some command to execute
+        :param exp_err_code: ('INTEGER') - expected error code
+        :param message: ('STRING') - command description
+        :param cwd: ('STRING') - path to directory, where need to execute cmd
+        :return:
+         - errcode ('INTEGER')
+        """
+        try:
+            errcode = subprocess.call(cmd, shell=True, cwd=cwd, stdout=sys.stderr.fileno())
+            if errcode != exp_err_code:
+                self.logger.debug("FAIL :: {0}".format(message))
+            else:
+                self.logger.debug("PASS ] :: [ {0}".format(message))
+            return errcode
+        except subprocess.CalledProcessError as exp:
+            self.logger.error("Could not execute command {0}, e: {1}".format(cmd, exp))
+
+    def check_package(self):
+        """
+        This method is used for checking, if zip package is installed
+        :return: None
+        """
+        assert self.run_cmd("dnf list installed zip", 0, "Dnf package should be installed") == 0
+
+    def check_output(self, cmd, exp_output, message, cwd=None):
+        """
+        This method is used for executing cmd and compare output result with expected message
+        :param cmd: (`STRING`) - some command to execute
+        :param exp_err_code: (`INTEGER`) - expected error code
+        :param message: (`STRING`) - command description
+        :param cwd: (`STRING`) - path to directory, where need to execute cmd
+        :return:
+        - output message (`STRING`)
+        """
+        try:
+            output = self.execute_cmd(cmd, cwd)
+            if output != exp_output:
+                self.logger.debug("FAIL ]:: [ {}".format(message))
+            else:
+                self.logger.debug("PASS ] :: [ {}".format(message))
+            return output
+        except subprocess.CalledProcessError as exp:
+            self.logger.error(r'FAIL ] :: [ Could not execute command: "{0}",\
+             ex: {1}'.format(cmd, exp))
+
+    def execute_cmd(self, cmd, cwd=None):
+        """
+        This method is used for executing cmd and return output message
+        :param cmd: (`STRING`) - some command to execute
+        :param cwd: (`STRING`) - path to directory, where need to execute cmd
+        :return:
+        - output message (`STRING`)
+        """
+        try:
+            output = subprocess.check_output(cmd, shell=True, cwd=cwd)
+            return output
+        except subprocess.CalledProcessError as exp:
+            self.logger.error(r'FAIL ] :: [ Could not execute command: "{0}",\
+                               ex: {1}'.format(cmd, exp))
+
+    def remove_file(self, file_path, is_directory=False):
+        """
+        This method is used for removing files or directories after execution of test cases
+        :param file_path:(`STRING`) - path to file/folder
+        :param is_directory: (`BOOLEAN`) - True for directories
+        :return: None
+        """
+        try:
+            if is_directory:
+                shutil.rmtree(file_path)
+            else:
+                os.remove(file_path)
+            self.logger.debug("File {0} has been successfully removed".format(file_path))
+        except OSError, exp:
+            self.logger.debug("File {0} doesn't exists, e: {1}".format(file_path, exp))

tests/tests/test_4GBsegfault.py

@@ -0,0 +1,89 @@
+# Copyright (c) 2018 Red Hat, Inc. All rights reserved. This copyrighted material
+# is made available to anyone wishing to use, modify, copy, or
+# redistribute it subject to the terms and conditions of the GNU General
+# Public License v.2.
+#
+# 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.
+#
+# Author: Eduard Sakaiev <esakaiev@redhat.com>
+
+import sys
+import uuid
+
+sys.path.append("..")
+
+from tests import BaseZipTests
+from tests import decorated_message
+
+PURPOSE = '''zip mustn't segfault when packing files larger than 4 GB.
+
+Note: this test can't run on RHEL 2.1 since the utilities used here
+in the test don't work there as expected. This test can't run on
+RHEL 5 either, but in this case, the reason is reworked zip which
+can't work with files larger than 4 GB at all.'''
+
+
+class Test4GBsegfault(BaseZipTests):
+    """
+        This class is used for providing functionality
+        for Test4GBsegfault test case
+    """
+
+    def __init__(self):
+        """
+
+        """
+        self._purpose = PURPOSE
+        super(Test4GBsegfault, self).__init__()
+
+        self._tmpdir = "/tmp/{}".format(uuid.uuid4())
+
+    @decorated_message("SETUP")
+    def prepare_setup(self):
+        """
+
+        :return:
+        """
+        self.check_package()
+
+        self.run_cmd("mkdir {}".format(self._tmpdir), 0,
+                     "Creating tmp directory {}".format(self._tmpdir))
+
+    @decorated_message("TEST")
+    def start_test(self):
+        """
+
+        :return:
+        """
+        self.run_cmd("dd if=/dev/zero of=testfile bs=1M count=4097", 0,
+                     "Creating of 4Gb file", self._tmpdir + "/")
+        self.run_cmd("zip testfile.zip testfile", 0,
+                     "Archiving file with zip", self._tmpdir + "/")
+
+    @decorated_message("CLEANUP")
+    def cleanup(self):
+        """
+
+        :return:
+        """
+        self.run_cmd("rm -r {}".format(self._tmpdir), 0,
+                     "Removing tmp directory")
+
+
+if __name__ == "__main__":
+    test_4gb = Test4GBsegfault()
+    try:
+        test_4gb.prepare_setup()
+        test_4gb.start_test()
+    except AssertionError, exp:
+        test_4gb.logger.debug("FAIL ] :: [ Assertion occurred {0}".format(exp))
+    except Exception, exp:
+        test_4gb.logger.debug("FAIL ] :: [ Exception occurred {0}".format(exp))
+    finally:
+        test_4gb.cleanup()

tests/tests/test_big_file_in_archive.py

@@ -0,0 +1,128 @@
+# python2 test_big_file_in_archive.py
+# Author: Josef Zila <jzila@redhat.com>
+# Location: CoreOS/zip/Functionality/stress-tests/big-file-in-archive/runtest.sh
+# Description: zip - tests handling large files (2GB,3MB,4GB)
+
+# Copyright (c) 2008 Red Hat, Inc. All rights reserved. This copyrighted material
+# is made available to anyone wishing to use, modify, copy, or
+# redistribute it subject to the terms and conditions of the GNU General
+# Public License v.2.
+#
+# 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.
+
+# Include rhts and rhtslib environment
+# rpm -q --quiet rhtslib || rpm -Uvh http://nest.test.redhat.com/mnt/qa/scratch/pmuller/rhtslib/rhtslib.rpm
+
+import sys
+import uuid
+import platform
+
+sys.path.append("..")
+
+from tests import BaseZipTests
+from tests import decorated_message
+
+PURPOSE = '''
+Test Name: Big file in archive
+Author: Josef Zila <jzila@redhat.com>
+Location: CoreOS/zip/Functionality/stress-tests/big-file-in-archive/PURPOSE
+
+Short Description:
+Tests handling large files (2GB,3GB,4GB)
+
+Long Description:
+Test creates three files (2GB, 3GB and 4GB large) and attempts to archive each of them using zip. Then original files are deleted
+and archives are unpacked, to check size of unpacked files. Current version of zip on all archs and distros in time of
+writing(2.31-1) passes test. Note: 4GB file is too large for zip to handle, so it is not supposed to be successfully archived
+or unpacked, test just checks for correct return codes.
+
+
+how to run it:
+python2 test_big_file_in_archive.py
+
+TEST UPDATED (esakaiev)
+------------------------
+After rebase to zip-3.0-1 there is no 4GB limit. Patching the test accordingly.
+'''
+
+
+class TestBigFileInArchive(BaseZipTests):
+    """
+        This class is used for providing functionality
+        for TestBigFileInArchive test case
+    """
+    def __init__(self):
+        """
+
+        """
+        self._purpose = PURPOSE
+        super(TestBigFileInArchive, self).__init__()
+
+        self._files = ['/tmp/tmp.{}'.format(uuid.uuid4()) for x in xrange(3)]
+        self._files_sizes = [2048, 3056, 4096]
+        self._os_distribution = platform.linux_distribution()
+
+    @decorated_message("Preparing Setup")
+    def prepare_setup(self):
+        """
+
+        :return:
+        """
+        self.check_package()
+        for i, file_name in enumerate(self._files):
+            size = self._files_sizes[i]
+            assert self.run_cmd("dd if=/dev/zero of={0} bs=1M count={1}".format(file_name, size), 0,
+                                "Creating {0} GB file".format(size / 1000), cwd="/tmp/") == 0
+
+    @decorated_message("Starting Test")
+    def start_test(self):
+        """
+
+        :return:
+        """
+        for i, file_name in enumerate(self._files):
+            error_code = 0
+
+            self.remove_file(file_name + ".zip")  # #remove archive temp files, we just need unused temp names
+            size = self._files_sizes[i]
+
+            self.run_cmd("zip {0} {1}".format(file_name + ".zip", file_name), error_code,
+                         "Archiving {} Gb file".format(size / 1000), cwd="/tmp/")
+
+            self.remove_file(file_name)  # Removing original files
+
+            self.run_cmd("unzip {0} -d /".format(file_name + ".zip"), error_code,
+                         "Unpacking {} Gb file".format(size / 1000), cwd="/tmp/")
+
+        # Checking new 2GB file size
+        self.check_output("stat -c %s {0}".format(self._files[0]), "2147483648\n", "Checking new 2GB file size")
+
+    @decorated_message("Cleaning up")
+    def cleanup(self):
+        """
+
+        :return:
+        """
+        for file_name in self._files:
+            self.remove_file(file_name)
+            self.remove_file(file_name + ".zip")
+
+
+if __name__ == "__main__":
+    test = TestBigFileInArchive()
+    try:
+        test.prepare_setup()
+        test.start_test()
+    except AssertionError, exp:
+        test.logger.debug("FAIL ] :: [ Assertion occurred {0}".format(exp))
+    except Exception, exp:
+        test.logger.debug("FAIL ] :: [ Exception occurred {0}".format(exp))
+    finally:
+        test.cleanup()

tests/tests/test_long_path_in_archive.py

@@ -0,0 +1,140 @@
+# Author: Josef Zila <jzila@redhat.com>
+# Location: CoreOS/zip/Functionality/stress-tests/long-path-in-archive/runtest.sh
+# Description: zip - tests handling very long paths within archive (15*256 characters long path)
+
+# Copyright (c) 2008 Red Hat, Inc. All rights reserved. This copyrighted material
+# is made available to anyone wishing to use, modify, copy, or
+# redistribute it subject to the terms and conditions of the GNU General
+# Public License v.2.
+#
+# 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.
+
+import sys
+import uuid
+import os
+from shutil import copyfile
+
+sys.path.append("..")
+
+from tests import BaseZipTests
+from tests import decorated_message
+
+PURPOSE = '''
+Test Name: 
+Author: Josef Zila <jzila@redhat.com>
+Location: CoreOS/zip/Functionality/stress-tests/long-path-in-archive/PURPOSE
+
+Short Description:
+Tests handling very long paths within archive (15*256 characters long path)
+
+Long Description:
+This test creates file with very long path of 15 directories, each 255 characters. This whole directory structure is then zipped and unzipped
+to determine if zip program handles paths this long correctly. Current version of zip on all archs and distros in time of writing(2.31-1) passes test.
+
+
+how to run it:
+choose arch and distro
+
+
+TEST UPDATED (esakaiev)
+'''
+
+
+class TestLongPathInArchive(BaseZipTests):
+    """
+        This class is used for providing functionality
+        for TestLongPathInArchive test case
+    """
+    def __init__(self):
+        self._purpose = PURPOSE
+        super(TestLongPathInArchive, self).__init__()
+
+        self._tmpdir = "/tmp/{}".format(uuid.uuid4())
+        self._file_under_test = "/proc/version"
+
+        self._long_name = "".join(["aaaaa" for i in xrange(51)])
+        self._long_path = "/".join([self._long_name for x in xrange(15)])
+        self._test_file_path = self._tmpdir + "/" + self._long_path + "/" + "testfile"
+        self._package_ver = ""
+        self._package_release = ""
+
+    @decorated_message("Prepare setup")
+    def prepare_setup(self):
+        """
+
+        :return:
+        """
+        self.check_package()
+
+        self.run_cmd("mkdir {}".format(self._tmpdir), 0, "Creating tmp directory {}".format(self._tmpdir))
+        self._package_ver = self.execute_cmd("rpm -q zip --queryformat %{version}")
+        self._package_release = self.execute_cmd("rpm -q zip --queryformat %{version}")
+
+        self.logger.debug("Running zip.{0}.{1} package".format(self._package_ver, self._package_release))
+        # creating folders structure:
+        try:
+
+            os.makedirs(self._tmpdir + "/" + self._long_path)
+            self.logger.debug("PASS ] :: [ Test directory with long path has been successfully created")
+        except OSError, exp:
+            self.logger.debug("FAIL ] :: [ Could not create directories by path, e: {}".format(exp))
+            raise
+
+        copyfile(self._file_under_test, self._test_file_path)
+
+    @decorated_message("Starting Test cases")
+    def start_test(self):
+        """
+
+        :return:
+        """
+
+        self.run_cmd("zip -r test {0} -q".format(self._long_name), 0,
+                     "Zipping test file",
+                     cwd=self._tmpdir)
+
+        self.remove_file(self._tmpdir + "/" + self._long_name, True)
+        self.run_cmd("unzip -qq test.zip", 0,
+                     "Unzipping test file",
+                     cwd=self._tmpdir)
+
+        content_init = None
+        with open(self._file_under_test) as fp_init:
+            content_init = fp_init.read().replace('\n', '')
+
+        content_fut = None
+        with open(self._test_file_path) as fp_fut:
+            content_fut = fp_fut.read().replace('\n', '')
+
+        if content_init == content_fut:
+            self.logger.debug("PASS ] :: [ {}".format("Content of the initial file and file under test was matched"))
+        else:
+            self.logger.debug("FAIL ] :: [ {}".format("Content of the initial file and file under test wasn't matched"))
+
+    @decorated_message("Cleaning up")
+    def cleanup(self):
+        """
+
+        :return:
+        """
+        self.remove_file(self._tmpdir, True)
+
+
+if __name__ == "__main__":
+    test = TestLongPathInArchive()
+    try:
+        test.prepare_setup()
+        test.start_test()
+    except AssertionError, exp:
+        test.logger.debug("FAIL ] :: [ Assertion occurred {0}".format(exp))
+    except Exception, exp:
+        test.logger.debug("FAIL ] :: [ Exception occurred {0}".format(exp))
+    finally:
+        test.cleanup()

tests/tests/test_many_files_in_archive.py

@@ -0,0 +1,140 @@
+# Author: Josef Zila <jzila@redhat.com>
+# Location: CoreOS/zip/Functionality/stress-tests/many-files-in-archive/runtest.sh
+# Description: zip - Tests behaviour with many files in archive (1048578 files)
+
+# Copyright (c) 2008 Red Hat, Inc. All rights reserved. This copyrighted material
+# is made available to anyone wishing to use, modify, copy, or
+# redistribute it subject to the terms and conditions of the GNU General
+# Public License v.2.
+#
+# 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.
+
+import sys
+import uuid
+
+sys.path.append("..")
+
+from tests import BaseZipTests
+from tests import decorated_message
+
+PURPOSE = '''
+Test Name: 
+Author: Josef Zila <jzila@redhat.com>
+Location: CoreOS/zip/Functionality/stress-tests/many-files-in-archive/PURPOSE
+
+Short Description:
+Tests behaviour with many files in archive (1048577 files)
+
+Long Description:
+This test creates 1048576 empty files and one non-empty file. Then zips and unzips directory containing all those files and tests content of 
+non-empty file and count of unzipped files. This test is very time-consuming. Current version of zip on all archs and distros in time of writing
+(2.31-1) passes test.
+
+
+how to run it:
+choose arch and distro
+
+
+TEST UPDATED (esakaiev)
+'''
+
+
+class TestManyFilesInArchive(BaseZipTests):
+    """
+        This class is used for providing functionality
+        for TestManyFilesInArchive test case
+    """
+
+    def __init__(self):
+        self._purpose = PURPOSE
+        super(TestManyFilesInArchive, self).__init__()
+
+        self._tmpdir = "/tmp/{}".format(uuid.uuid4())
+        self._files_number = 1048576
+        self._package_ver = ""
+        self._package_release = ""
+
+    @decorated_message("Prepare setup")
+    def prepare_setup(self):
+        """
+
+        :return:
+        """
+        self.check_package()
+
+        self.run_cmd("mkdir {}".format(self._tmpdir), 0,
+                     "Creating tmp directory {}".format(self._tmpdir))
+        self._package_ver = self.execute_cmd("rpm -q zip --queryformat %{version}")
+        self._package_release = self.execute_cmd("rpm -q zip --queryformat %{version}")
+
+        self.logger.debug("Running zip.{0}.{1} package".format(self._package_ver, self._package_release))
+        self.logger.debug("Creating {0} files".format(self._files_number))
+
+        [open("{0}/{1}".format(self._tmpdir, i), "w").close() for i in xrange(self._files_number)]
+        self.logger.debug("Creating test file")
+        with open("{0}/test.txt".format(self._tmpdir), "w") as fp:
+            fp.write("12345")
+
+    @decorated_message("Starting Test cases")
+    def start_test(self):
+        """
+
+        :return:
+        """
+
+        self.run_cmd("zip -r test {0} -q".format(self._tmpdir.split('/')[-1]), 0,
+                     "Zipping test files",
+                     cwd='/tmp')
+
+        self.remove_file(self._tmpdir, True)
+        self.run_cmd("unzip -qq test.zip", 0,
+                     "Unzipping test files",
+                     cwd='/tmp')
+
+        test_file_content = None
+        with open("{0}/test.txt".format(self._tmpdir)) as fp:
+            test_file_content = fp.read().replace('/n', '')
+
+        if test_file_content == "12345":
+            self.logger.debug("PASS ] :: [ {}".format("Unpacked content matches original"))
+        else:
+            self.logger.debug("FAIL ] :: [ {}".format("Unpacked content does not match original!"))
+
+        files_count = self.execute_cmd("ls {0} | wc -l".format(self._tmpdir)).replace("\n", "")
+
+        if files_count == str(self._files_number + 1):
+            self.logger.debug(
+                "PASS ] :: [ {}".format("All {0} files present after unpacking".format(self._files_number + 1)))
+        else:
+            self.logger.debug(r"FAIL ] :: [ File count changed after unpacking! \
+                                           Before zipping there was {0} files. \
+                                           After unzip there is {1} files.".format(self._files_number + 1, files_count))
+
+    @decorated_message("Cleaning up")
+    def cleanup(self):
+        """
+
+        :return:
+        """
+        self.remove_file(self._tmpdir, True)
+        self.remove_file("/tmp/test.zip")
+
+
+if __name__ == "__main__":
+    test = TestManyFilesInArchive()
+    try:
+        test.prepare_setup()
+        test.start_test()
+    except AssertionError, exp:
+        test.logger.debug("FAIL ] :: [ Assertion occurred {0}".format(exp))
+    except Exception, exp:
+        test.logger.debug("FAIL ] :: [ Exception occurred {0}".format(exp))
+    finally:
+        test.cleanup()

tests/tests/test_umask.py

@@ -0,0 +1,106 @@
+# Copyright (c) 2006 Red Hat, Inc. All rights reserved. This copyrighted material
+# is made available to anyone wishing to use, modify, copy, or
+# redistribute it subject to the terms and conditions of the GNU General
+# Public License v.2.
+#
+# 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.
+#
+# Author: Radek Biba <rbiba@redhat.com>
+
+import sys
+import uuid
+
+UMASK = "Running umask"
+
+sys.path.append("..")
+
+from tests import BaseZipTests
+from tests import decorated_message
+
+PURPOSE = '''
+zip is supposed to honor umask settings when creating archives.
+This test case just checks if it really does
+
+TEST UPDATED (esakaiev)
+'''
+
+
+class TestUmask(BaseZipTests):
+    """
+        This class is used for providing functionality
+        for TestUmask test case
+    """
+    def __init__(self):
+        self._purpose = PURPOSE
+        super(TestUmask, self).__init__()
+
+        self._tmpdir = "/tmp/{}".format(uuid.uuid4())
+        self._mask_list = ["0", "2", "20", "22", "200", "202", "220", "222", "6", "60"]
+        self._package_ver = ""
+        self._package_release = ""
+
+    @decorated_message("Prepare setup")
+    def prepare_setup(self):
+        """
+
+        :return:
+        """
+        self.check_package()
+
+        self.run_cmd("mkdir {}".format(self._tmpdir), 0, "Creating tmp directory {}".format(self._tmpdir))
+        self._package_ver = self.execute_cmd("rpm -q zip --queryformat %{version}")
+        self._package_release = self.execute_cmd("rpm -q zip --queryformat %{version}")
+
+        self.logger.debug("Running zip.{0}.{1} package".format(self._package_ver, self._package_release))
+
+    # Trying to verify that zip honors umask. Trying with various combinations
+    # of 'w's and 'r's for User, Group, and Others.
+    @decorated_message("Starting Test cases")
+    def start_test(self):
+        """
+
+        :return:
+        """
+        for mask in self._mask_list:
+            self.logger.debug("Running umask and zipping file {0}".format(mask))
+            self.execute_cmd("umask {0}; touch {0}; zip -q {0}.zip {0}".format(mask), cwd=self._tmpdir)
+
+            stat_test_zip = self.execute_cmd("stat -c %a {0}.zip".format(mask), cwd=self._tmpdir).replace("\n", "")
+            stat_test = self.execute_cmd("stat -c %a {0}".format(mask), cwd=self._tmpdir).replace("\n", "")
+
+            print stat_test_zip, stat_test
+            if stat_test_zip == stat_test:
+                self.logger.debug(
+                    "PASS ] :: [ permissions for {0}.zip match to {0}, {1} == {2}".format(mask, stat_test_zip,
+                                                                                          stat_test))
+            else:
+                self.logger.debug(
+                    "FAIL ] :: [ permissions for {0}.zip doesn't match to {0}, {1} != {2}".format(mask, stat_test_zip,
+                                                                                                  stat_test))
+
+    @decorated_message("Cleaning up")
+    def cleanup(self):
+        """
+
+        :return:
+        """
+        self.remove_file(self._tmpdir, True)
+
+
+if __name__ == "__main__":
+    test = TestUmask()
+    try:
+        test.prepare_setup()
+        test.start_test()
+    except AssertionError, exp:
+        test.logger.debug("FAIL ] :: [ Assertion occurred {0}".format(exp))
+    except Exception, exp:
+        test.logger.debug("FAIL ] :: [ Exception occurred {0}".format(exp))
+    finally:
+        test.cleanup()

tests/tests/test_umask_when_creating.py

@@ -0,0 +1,105 @@
+# Author: Josef Zila <jzila@redhat.com>
+
+# Description:  Zip did not honor umask setting when creating archives.
+
+# Copyright (c) 2008 Red Hat, Inc. All rights reserved. This copyrighted material
+# is made available to anyone wishing to use, modify, copy, or
+# redistribute it subject to the terms and conditions of the GNU General
+# Public License v.2.
+#
+# 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.
+
+import sys
+import uuid
+
+UMASK = "Running umask"
+
+sys.path.append("..")
+
+from tests import BaseZipTests
+from tests import decorated_message
+
+PURPOSE = '''
+Test Name: umask-when-creating
+Author: Josef Zila <jzila@redhat.com>
+
+Short Description:
+zip does not honor umaks setting when creating archive
+
+Long Description:
+
+zip appears to have a built-in umask of 0022 regardless of the global umask.
+With umask set to 0000, zip-2.3-27 creates zip files with permissions of
+0644 instead of 0666.  Previous versions created files with correct permissions.
+
+
+TEST UPDATED (esakaiev)
+'''
+
+
+class TestUmaskWhenCreating(BaseZipTests):
+    """
+        This class is used for providing functionality
+        for TestUmaskWhenCreating test case
+    """
+    def __init__(self):
+        self._purpose = PURPOSE
+        super(TestUmaskWhenCreating, self).__init__()
+
+        self._tmpdir = "/tmp/{}".format(uuid.uuid4())
+        self._mask_list = ["777", "000", "027"]
+        self._expected_results = ["----------", "-rw-rw-rw-", "-rw-r-----"]
+        self._package_ver = ""
+        self._package_release = ""
+
+    @decorated_message("Prepare setup")
+    def prepare_setup(self):
+        self.check_package()
+
+        self.run_cmd("mkdir {}".format(self._tmpdir), 0, "Creating tmp directory {}".format(self._tmpdir))
+        self._package_ver = self.execute_cmd("rpm -q zip --queryformat %{version}")
+        self._package_release = self.execute_cmd("rpm -q zip --queryformat %{version}")
+
+        self.logger.debug("Running zip.{0}.{1} package".format(self._package_ver, self._package_release))
+
+    @decorated_message("Starting Test cases")
+    def start_test(self):
+        for i, mask in enumerate(self._mask_list):
+            self.logger.debug("Running umask and zipping file {0}".format(mask))
+            self.execute_cmd("umask -S {0} >> /dev/null; zip test /etc/services >> /dev/null".format(mask),
+                             cwd=self._tmpdir)
+
+            result = self.execute_cmd("ls -l test.zip | cut -b 1-10", cwd=self._tmpdir).replace("\n", "")
+
+            if result == self._expected_results[i]:
+                self.logger.debug(
+                    "PASS ] :: [ file permissions match to {0}".format(self._expected_results[i]))
+            else:
+                self.logger.debug(
+                    "FAIL ] :: [ file permissions don't match to {0}".format(self._expected_results[i]))
+
+            self.remove_file(self._tmpdir + "/" + "test.zip")
+
+    @decorated_message("Cleaning up")
+    def cleanup(self):
+        self.remove_file(self._tmpdir, True)
+
+
+if __name__ == "__main__":
+    test = TestUmaskWhenCreating()
+    try:
+        test.prepare_setup()
+        test.start_test()
+    except AssertionError, exp:
+        test.logger.debug("FAIL ] :: [ Assertion occurred {0}".format(exp))
+    except Exception, exp:
+        test.logger.debug("FAIL ] :: [ Exception occurred {0}".format(exp))
+    finally:
+        test.cleanup()

tests/tests/test_zipnote_fails_to_update_the_archive.py

@@ -0,0 +1,105 @@
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+#   Description: zipnote fails to update the archive
+#   Author: Karel Volny <kvolny@redhat.com>
+#
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+#   Copyright (c) 2015 Red Hat, Inc.
+#
+#   This copyrighted material is made available to anyone wishing
+#   to use, modify, copy, or redistribute it subject to the terms
+#   and conditions of the GNU General Public License version 2.
+#
+#   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.
+#
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+import sys
+import uuid
+
+sys.path.append("..")
+
+from tests import BaseZipTests
+from tests import decorated_message
+
+PURPOSE = '''
+PURPOSE of zipnote-fails-to-update-the-archive
+Description: zipnote fails to update the archive
+Author: Karel Volny <kvolny@redhat.com>
+
+
+TEST UPDATED (esakaiev)
+'''
+
+
+class TestZipnoteFailsToUpdateTheArchive(BaseZipTests):
+    """
+        This class is used for providing functionality
+        for TestZipnoteFailsToUpdateTheArchive test case
+    """
+    def __init__(self):
+        self._purpose = PURPOSE
+        super(TestZipnoteFailsToUpdateTheArchive, self).__init__()
+
+        self._tmpdir = '/tmp/tmp.{}'.format(uuid.uuid4())
+
+    @decorated_message("Preparing setup")
+    def prepare_setup(self):
+        """
+
+        :return:
+        """
+        self.check_package()
+        self.run_cmd("mkdir {}".format(self._tmpdir), 0, "Creating tmp directory {}".format(self._tmpdir))
+
+    @decorated_message("Starting Test")
+    def start_test(self):
+        """
+
+        :return:
+        """
+        self.run_cmd("touch file", 0, "Creating the Demo file", cwd=self._tmpdir)
+        self.run_cmd("zip archive.zip file", 0, "Creating the archive including the file", cwd=self._tmpdir)
+        self.run_cmd("zipnote archive.zip > info.txt", 0, "Reading the archive comments", cwd=self._tmpdir)
+        ## bad - e.g. zip-3.0-1.el6.i686:
+        # zipnote error: Interrupted (aborting)
+        # Segmentation fault
+        ## good: no output
+        self.run_cmd("zipnote -w archive.zip < info.txt > output_file.txt 2>&1", 0, "Writing comments to the archive",
+                     cwd=self._tmpdir)
+
+        if 'error' in open(self._tmpdir + '/output_file.txt').read():
+            self.logger.debug("FAIL ] :: [ File shouldn't contain an error pattern")
+        else:
+            self.logger.debug("PASS ] :: [ File doesn't contain an error pattern")
+
+    @decorated_message("Cleaning up")
+    def cleanup(self):
+        """
+
+        :return:
+        """
+        self.run_cmd("rm -r {}".format(self._tmpdir), 0,
+                     "Removing tmp directory")
+
+
+if __name__ == "__main__":
+    test = TestZipnoteFailsToUpdateTheArchive()
+    try:
+        test.prepare_setup()
+        test.start_test()
+    except AssertionError, exp:
+        test.logger.debug("FAIL ] :: [ Assertion occurred {0}".format(exp))
+    except Exception, exp:
+        test.logger.debug("FAIL ] :: [ Exception occurred {0}".format(exp))
+    finally:
+        test.cleanup()