def run_check(cls, results_dir):
        """ Compares old and new RPMs using pkgdiff """
        results_dict = {}

        for tag in settings.CHECKER_TAGS:
            results_dict[tag] = []
        cls.results_dir = results_dir

        # Only S (size), M(mode) and 5 (checksum) are now important
        not_catched_flags = ['T', 'F', 'G', 'U', 'V', 'L', 'D', 'N']
        old_pkgs = cls._get_rpms(OutputLogger.get_build('old').get('rpm', None))
        new_pkgs = cls._get_rpms(OutputLogger.get_build('new').get('rpm', None))
        for key, value in six.iteritems(old_pkgs):
            cmd = [cls.CMD]
            # TODO modify to online command
            for x in not_catched_flags:
                cmd.extend(['-i', x])
            cmd.append(value)
            # We would like to build correct old package against correct new packages
            cmd.append(new_pkgs[key])
            output = StringIO()
            ProcessHelper.run_subprocess(cmd, output=output)
            results_dict = cls._analyze_logs(output, results_dict)

        results_dict = cls.update_added_removed(results_dict)
        results_dict = dict((k, v) for k, v in six.iteritems(results_dict) if v)
        text = []
        for key, val in six.iteritems(results_dict):
            text.append('Following files were %s:\n%s' % (key, '\n'.join(val)))
        return text

 def call_prep_script(cls, prep_script_path):
     cwd = os.getcwd()
     os.chdir(cls.old_sources)
     ProcessHelper.run_subprocess(prep_script_path, output=os.path.join(cls.kwargs['results_dir'], 'prep_script.log'))
     if not cls.patch_sources_by_prep_script:
         cls.git_helper.command_add_files(parameters=["--all"])
         cls.git_helper.command_commit(message="prep_script prep_corrections")
     os.chdir(cwd)

    def run_check(cls, results_dir):
        """ Compares old and new RPMs using pkgdiff """
        results_dict = {}

        for tag in settings.CHECKER_TAGS:
            results_dict[tag] = []
        cls.results_dir = results_dir

        # Only S (size), M(mode) and 5 (checksum) are now important
        not_catched_flags = ['T', 'F', 'G', 'U', 'V', 'L', 'D', 'N']
        old_pkgs = cls._get_rpms(OutputLogger.get_build('old').get('rpm', None))
        new_pkgs = cls._get_rpms(OutputLogger.get_build('new').get('rpm', None))
        for key, value in six.iteritems(old_pkgs):
            cmd = [cls.CMD]
            # TODO modify to online command
            for x in not_catched_flags:
                cmd.extend(['-i', x])
            cmd.append(value)
            # We would like to build correct old package against correct new packages
            cmd.append(new_pkgs[key])
            output = StringIO()
            ret_code = ProcessHelper.run_subprocess(cmd, output=output)
            results_dict = cls._analyze_logs(output, results_dict)

        results_dict = cls.update_added_removed(results_dict)
        # TODO Check for changed files and
        # remove them from 'removed' and 'added'
        #cls._unpack_rpm(old_pkgs)
        #cls._unpack_rpm(new_pkgs)
        #cls._find_file_diffs(old_pkgs, new_pkgs)
        return results_dict

 def test_simple_cmd_with_redirected_output_fileobject(self):
     buff = StringIO()
     ret = ProcessHelper.run_subprocess(self.ECHO_COMMAND, output=buff)
     assert ret == 0
     assert not os.path.exists(self.OUT_FILE)
     assert buff.readline().strip("\n") == self.PHRASE
     buff.close()

    def _do_build_srpm(cls, spec, workdir, results_dir):
        """
        Build SRPM using rpmbuild.

        :param spec: abs path to SPEC file inside the rpmbuild/SPECS in workdir.
        :param workdir: abs path to working directory with rpmbuild directory
                        structure, which will be used as HOME dir.
        :param results_dir: abs path to dir where the log should be placed.
        :return: If build process ends successfully returns abs path
                 to built SRPM, otherwise 'None'.
        """
        logger.info("Building SRPM")
        spec_loc, spec_name = os.path.split(spec)
        output = os.path.join(results_dir, "build.log")

        cmd = ['rpmbuild', '-bs', spec_name]
        ret = ProcessHelper.run_subprocess_cwd_env(cmd,
                                                   cwd=spec_loc,
                                                   env={'HOME': workdir},
                                                   output=output)

        if ret != 0:
            return None
        else:
            return PathHelper.find_first_file(workdir, '*.src.rpm')

 def test_simple_cmd_changed_work_dir_with_redirected_output(self):
     # create temp_file in temp_dir
     self.test_simple_cmd_changed_work_dir()
     ret = ProcessHelper.run_subprocess_cwd(self.LS_COMMAND, self.TEMP_DIR, output=self.OUT_FILE)
     assert ret == 0
     assert os.path.exists(os.path.join(self.TEMP_DIR, self.TEMP_FILE))
     assert os.path.exists(self.OUT_FILE)
     assert open(self.OUT_FILE).readline().strip("\n") == self.TEMP_FILE

    def run_check(cls, result_dir):
        """Compares old and new RPMs using pkgdiff"""
        debug_old, rest_pkgs_old = cls._get_packages_for_abipkgdiff(OutputLogger.get_build('old'))
        debug_new, rest_pkgs_new = cls._get_packages_for_abipkgdiff(OutputLogger.get_build('new'))
        cmd = [cls.CMD]
        if debug_old is None:
            logger.warning("Package doesn't contain any debug package")
            return None
        try:
            cmd.append('--d1')
            cmd.append(debug_old[0])
        except IndexError:
            logger.error('Debuginfo package not found for old package.')
            return None
        try:
            cmd.append('--d2')
            cmd.append(debug_new[0])
        except IndexError:
            logger.error('Debuginfo package not found for new package.')
            return None
        reports = {}
        for pkg in rest_pkgs_old:
            command = list(cmd)
            # Package can be <letters><numbers>-<letters>-<and_whatever>
            regexp = r'^(\w*)(-\D+)?.*$'
            reg = re.compile(regexp)
            matched = reg.search(os.path.basename(pkg))
            if matched:
                file_name = matched.group(1)
                command.append(pkg)
                find = [x for x in rest_pkgs_new if os.path.basename(x).startswith(file_name)]
                command.append(find[0])
                package_name = os.path.basename(os.path.basename(pkg))
                logger.debug('Package name for ABI comparision %s', package_name)
                regexp_name = r'(\w-)*(\D+)*'
                reg_name = re.compile(regexp_name)
                matched = reg_name.search(os.path.basename(pkg))
                logger.debug('Found matches %s', matched.groups())
                if matched:
                    package_name = matched.group(0) + cls.log_name
                else:
                    package_name = package_name + '-' + cls.log_name
                output = os.path.join(cls.results_dir, result_dir, package_name)
                try:
                    ret_code = ProcessHelper.run_subprocess(command, output=output)
                except OSError:
                    raise CheckerNotFoundError("Checker '%s' was not found or installed." % cls.CMD)

                if int(ret_code) & settings.ABIDIFF_ERROR and int(ret_code) & settings.ABIDIFF_USAGE_ERROR:
                    raise RebaseHelperError('Execution of %s failed.\nCommand line is: %s' % (cls.CMD, cmd))
                if int(ret_code) == 0:
                    text = 'ABI of the compared binaries in package %s are equal.' % package_name
                else:
                    text = 'ABI of the compared binaries in package %s are not equal.' % package_name
                reports[output] = text
            else:
                logger.debug("Rebase-helper did not find a package name in '%s'", package_name)
        return reports

        def test_simple_cmd_with_input_path_and_redirected_output_path(self):
            with open(self.IN_FILE, "w") as f:
                f.write(self.PHRASE)

            assert os.path.exists(self.IN_FILE)
            assert open(self.IN_FILE).readline().strip("\n") == self.PHRASE

            ret = ProcessHelper.run_subprocess(self.CAT_COMMAND, input=self.IN_FILE, output=self.OUT_FILE)
            assert ret == 0
            assert os.path.exists(self.OUT_FILE)
            assert open(self.OUT_FILE).readline().strip("\n") == self.PHRASE

        def test_simple_cmd_with_input_fileobject_and_redirected_output_path(self):
            in_buff = StringIO()
            in_buff.write(self.PHRASE)

            assert not os.path.exists(self.IN_FILE)
            in_buff.seek(0)
            assert in_buff.readline().strip("\n") == self.PHRASE

            ret = ProcessHelper.run_subprocess(self.CAT_COMMAND, input=in_buff, output=self.OUT_FILE)
            in_buff.close()
            assert ret == 0
            assert os.path.exists(self.OUT_FILE)
            assert open(self.OUT_FILE).readline().strip("\n") == self.PHRASE

    def run_check(cls, results_dir):
        """Compares old and new RPMs using pkgdiff"""
        csmock_report = {}

        old_pkgs = OutputLogger.get_old_build().get('srpm', None)
        new_pkgs = OutputLogger.get_new_build().get('srpm', None)
        csmock_dir = os.path.join(results_dir, cls.CMD)
        os.makedirs(csmock_dir)
        arguments = ['--force', '-a', '-r', 'fedora-rawhide-x86_64', '--base-srpm']
        if old_pkgs and new_pkgs:
            cmd = [cls.CMD]
            cmd.extend(arguments)
            cmd.append(old_pkgs)
            cmd.append(new_pkgs)
            cmd.extend(['-o', csmock_dir])
            output = StringIO()
            try:
                ProcessHelper.run_subprocess(cmd, output=output)
            except OSError:
                raise CheckerNotFoundError("Checker '%s' was not found or installed." % cls.CMD)
        csmock_report['error'] = PathHelper.find_all_files_current_dir(csmock_dir, '*.err')
        csmock_report['txt'] = PathHelper.find_all_files_current_dir(csmock_dir, '*.txt')
        csmock_report['log'] = PathHelper.find_all_files_current_dir(csmock_dir, '*.log')
        return csmock_report

        def test_simple_cmd_with_input_path_and_redirected_output_fileobject(self):
            out_buff = StringIO()
            with open(self.IN_FILE, 'w') as f:
                f.write(self.PHRASE)

            assert os.path.exists(self.IN_FILE)
            assert open(self.IN_FILE).readline().strip('\n') == self.PHRASE

            ret = ProcessHelper.run_subprocess(self.CAT_COMMAND,
                                               input=self.IN_FILE,
                                               output=out_buff)
            assert ret == 0
            assert not os.path.exists(self.OUT_FILE)
            out_buff.seek(0)
            assert out_buff.readline().strip('\n') == self.PHRASE
            out_buff.close()

    def _build_rpm(cls, srpm, results_dir, root=None, arch=None):
        """Build RPM using mock."""
        logger.info("Building RPMs")
        output = os.path.join(results_dir, "mock_output.log")

        cmd = [cls.CMD, '--rebuild', srpm, '--resultdir', results_dir]
        if root is not None:
            cmd.extend(['--root', root])
        if arch is not None:
            cmd.extend(['--arch', arch])

        ret = ProcessHelper.run_subprocess(cmd, output=output)

        if ret != 0:
            return None
        else:
            return [f for f in PathHelper.find_all_files(results_dir, '*.rpm') if not f.endswith('.src.rpm')]

    def _build_srpm(cls, spec, sources, results_dir, root=None, arch=None):
        """Build SRPM using mock."""
        logger.info("Building SRPM")
        output = os.path.join(results_dir, "mock_output.log")

        cmd = [cls.CMD, '--buildsrpm', '--spec', spec, '--sources', sources,
               '--resultdir', results_dir]
        if root is not None:
            cmd.extend(['--root', root])
        if arch is not None:
            cmd.extend(['--arch', arch])

        ret = ProcessHelper.run_subprocess(cmd, output=output)
        if ret != 0:
            return None
        else:
            return PathHelper.find_first_file(results_dir, '*.src.rpm')

        def test_setting_new_env(self):
            # make copy of existing environment
            en_variables = os.environ.copy().keys()

            # pick up non-existing name
            while True:
                rand_name = "".join(random.choice(string.ascii_letters) for _ in range(6)).upper()
                if rand_name not in en_variables:
                    break

            cmd = 'echo "$' + rand_name + '"'
            ret = ProcessHelper.run_subprocess_cwd_env(
                cmd, env={rand_name: self.PHRASE}, output=self.OUT_FILE, shell=True
            )
            assert ret == 0
            assert os.path.exists(self.OUT_FILE)
            assert open(self.OUT_FILE).readline().strip("\n") == self.PHRASE

        def test_setting_existing_env(self):
            # make copy of existing environment
            en_variables = list(os.environ.copy().keys())

            # there are no variables set on the system -> nothing to test
            if not en_variables:
                pass

            assert os.environ.get(en_variables[0]) != self.PHRASE

            cmd = 'echo "$' + en_variables[0] + '"'
            ret = ProcessHelper.run_subprocess_cwd_env(
                cmd, env={en_variables[0]: self.PHRASE}, output=self.OUT_FILE, shell=True
            )
            assert ret == 0
            assert os.path.exists(self.OUT_FILE)
            assert open(self.OUT_FILE).readline().strip("\n") == self.PHRASE

 def test_simple_cmd(self):
     ret = ProcessHelper.run_subprocess(self.TOUCH_COMMAND)
     assert ret == 0
     assert os.path.exists(self.TEMP_FILE)

 def test_simple_cmd_with_redirected_output_path(self):
     ret = ProcessHelper.run_subprocess(self.ECHO_COMMAND, output=self.OUT_FILE)
     assert ret == 0
     assert os.path.exists(self.OUT_FILE)
     assert open(self.OUT_FILE).readline().strip("\n") == self.PHRASE

 def test_simple_cmd_changed_work_dir(self):
     os.mkdir(self.TEMP_DIR)
     ret = ProcessHelper.run_subprocess_cwd(self.TOUCH_COMMAND, self.TEMP_DIR)
     assert ret == 0
     assert os.path.exists(os.path.join(self.TEMP_DIR, self.TEMP_FILE))