def load_localarch(self):

          """Get the local arch as defined by rpm"""

                                  stdout=subprocess.PIPE,

                                  universal_newlines=True)

          self._localarch = proc.communicate()[0].strip('\n')

          if self.uses_rpmautospec and rpmautospec_calculate_release_number:

              release_number = rpmautospec_calculate_release_number(specfile_path)

          # We make sure there is a space at the end of our query so that

          # we can split it later.  When there are subpackages, we get a

          # listing for each subpackage.  We only care about the first.

          joined_cmd = ' '.join(cmd)

          try:

                                      universal_newlines=True,

                                      stdout=subprocess.PIPE,

                                      stderr=subprocess.PIPE)

          if self.uses_rpmautospec and rpmautospec_calculate_release_number:

              release_number = rpmautospec_calculate_release_number(specfile_path)

          # setup the command

          cmd = ['mock']

          # We make sure there is a space at the end of our query so that

          # we can split it later.  When there are subpackages, we get a

          # listing for each subpackage.  We only care about the first.

              + ['> ' + os.path.join(tmp_root, 'output')]

          copyout_cmd = cmd + ['--copyout', os.path.join(tmp_root, 'output'), tmp_resultdir]

          self._distvar, self._distval = osver.split('-')

          self._distval = self._distval.replace('.', '_')

          self._disttag = 'el%s' % self._distval

                              # int and float this to remove the decimal

      @property

      def spec(self):

          if shell:

              command = ' '.join(cmd)

              pipecmd = ' '.join(pipe)

          if pipe:

              self.log.debug('Running: %s | %s', ' '.join(cmd), ' '.join(pipe))

                  # bad thing, but rpmbuild likes to put useful data on

                  # stderr, so....

                  parent_proc = subprocess.Popen(

                      stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

                  proc = subprocess.Popen(

                      stdin=parent_proc.stdout,

                      stdout=proc_stdout, stderr=proc_stderr,

                      universal_newlines=return_text)

              else:

                  proc = subprocess.Popen(

                      stdout=proc_stdout, stderr=proc_stderr,

                      universal_newlines=return_text)

          except KeyboardInterrupt:

          # Command contains workaround (undefines _changelog_trimtime) described at:

          # https://github.com/rpm-software-management/rpm/issues/1301

          # It caused, that older changelog records were not displayed.

                                  stdout=subprocess.PIPE, stderr=subprocess.PIPE,

                                  universal_newlines=True)

          stdout, stderr = proc.communicate()

          cmd.extend(self.rpmdefines)

          if builddir:

              # Tack on a new builddir to the end of the defines

          if arch:

              cmd.extend(['--target', arch])

          if define:

              cmd.append('--quiet')

          cmd.extend(['-bc', os.path.join(self.path, self.spec)])

          # Run the command

      def giturl(self):

          """Return the git url that would be used for building"""

          cmd.extend(self.rpmdefines)

          if builddir:

              # Tack on a new builddir to the end of the defines

          if arch:

              cmd.extend(['--target', arch])

          if define:

          if self.quiet:

              cmd.append('--quiet')

          if buildrootdir:

          cmd.extend(['-bi', os.path.join(self.path, self.spec)])

          # Run the command

          return

      def lint(self, info=False, rpmlintconf=None):

          cmd.append(os.path.join(self.layout.specdir, self.spec))

          cmd.extend(sorted(rpms))

      def list_side_tags(self, base_tag=None, user=None):

          return self.kojisession.listSideTags(basetag=base_tag, user=user)

          cmd.extend(self.rpmdefines + localargs)

          if builddir:

              # Tack on a new builddir to the end of the defines

          if arch:

              cmd.extend(['--target', arch])

          if define:

          if self.quiet:

              cmd.append('--quiet')

          if buildrootdir:

          # Figure out the hash type to use

          if not hashtype:

              # Try to determine the dist

              hashtype = self._guess_hashtype()

          # This may need to get updated if we ever change our checksum default

          if not hashtype == 'sha256':

          specpath = os.path.join(self.path, self.spec)

          tmpdir = None

          try:

                  cmd.extend(['-ba', tmpspecpath])

              logfile = '.build-%s-%s.log' % (self.ver, self.rel)

              try:

          finally:

              self._cleanup_tmp_dir(tmpdir)

          cmd.extend(self.rpmdefines)

          if builddir:

              # Tack on a new builddir to the end of the defines

          if arch:

              cmd.extend(['--target', arch])

          if define:

          if self.quiet:

              cmd.append('--quiet')

          if buildrootdir:

          cmd.extend(['--nodeps', '-bp', os.path.join(self.path, self.spec)])

          # Run the command

      def srpm(self, hashtype=None, define=None, builddir=None, buildrootdir=None,

               arch=None, extra_args=None):

          cmd.extend(self.rpmdefines)

          if builddir:

              # Tack on a new builddir to the end of the defines

          if arch:

              cmd.extend(['--target', arch])

          if define:

          if self.quiet:

              cmd.append('--quiet')

          if buildrootdir:

          # Figure out which hashtype to use, if not provided one

          if not hashtype:

              hashtype = self._guess_hashtype()

          # This may need to get updated if we ever change our checksum default

          if not hashtype == 'sha256':

          specpath = os.path.join(self.path, self.spec)

          tmpdir = None

          try:

                  tmpspecpath = os.path.join(tmpdir, self.spec)

                  rpmautospec_process_distgit(specpath, tmpspecpath)

                  cmd.extend(['--nodeps', '-bs', tmpspecpath])

          finally:

              self._cleanup_tmp_dir(tmpdir)

          cmd.extend(self.rpmdefines)

          if builddir:

              # Tack on a new builddir to the end of the defines

          if define:

              for entry in define:

                  cmd.extend(['--define', entry])

          if self.quiet:

              cmd.append('--quiet')

          if buildrootdir:

          cmd.extend(['-bl', os.path.join(self.path, self.spec)])

          # Run the command

      def _process_koji_task_result(self, task_id):

          """

          expected_cmd = ['rpmbuild'] + cli.cmd.rpmdefines + \

              ['--nodeps', '-bs', os.path.join(cli.cmd.path, cli.cmd.spec)]

      @patch('pyrpkg.Commands._run_command')

      def test_srpm_with_options(self, _run_command):

          cli_cmd = ['rpkg', '--path', self.cloned_repo_path, '--release', 'rhel-6', 'srpm',

          with patch('sys.argv', new=cli_cmd):

              cli = self.new_cli()

              cli.srpm()

          expected_cmd = ['rpmbuild'] + cli.cmd.rpmdefines + \

               os.path.join(cli.cmd.path, cli.cmd.spec)]

      @patch('pyrpkg.Commands._run_command')

      def test_srpm_with_extra_args(self, _run_command):

          cli_cmd = ['rpkg', '--path', self.cloned_repo_path, '--release', 'rhel-6', 'srpm',

          with patch('sys.argv', new=cli_cmd):

              cli = self.new_cli()

              cli.srpm()

          expected_cmd = ['rpmbuild'] + cli.cmd.rpmdefines + \

               os.path.join(cli.cmd.path, cli.cmd.spec)]

  class TestCompile(CliTestCase):

          spec = os.path.join(cli.cmd.path, cli.cmd.spec)

          rpmbuild = ['rpmbuild'] + cli.cmd.rpmdefines + ['-bc', spec]

      @patch('pyrpkg.Commands._run_command')

      def test_compile_with_options(self, _run_command):

          spec = os.path.join(cli.cmd.path, cli.cmd.spec)

          rpmbuild = ['rpmbuild'] + cli.cmd.rpmdefines + \

               '--define', 'macro1 meansthis', '--rmspec', '--short-circuit',

               '--nocheck', '--quiet', '-bc', spec]

  class TestPrep(CliTestCase):

          spec = os.path.join(cli.cmd.path, cli.cmd.spec)

          rpmbuild = ['rpmbuild'] + cli.cmd.rpmdefines + ['--nodeps', '-bp', spec]

      @patch('pyrpkg.Commands._run_command')

      def test_prep_with_options(self, _run_command):

          spec = os.path.join(cli.cmd.path, cli.cmd.spec)

          rpmbuild = ['rpmbuild'] + cli.cmd.rpmdefines + [

              '--nodeps', '-bp', spec

          ]

      @patch('pyrpkg.Commands._run_command')

      def test_prep_extra_args_with_space(self, _run_command):

                                                          shlex.quote(first_arg_with_space),

                                                          shlex.quote(second_arg_with_space),

                                                          '--nodeps', '-bp', spec]

  class TestInstall(CliTestCase):

          spec = os.path.join(cli.cmd.path, cli.cmd.spec)

          rpmbuild = ['rpmbuild'] + cli.cmd.rpmdefines + ['-bi', spec]

      @patch('pyrpkg.Commands._run_command')

      def test_install_with_options(self, _run_command):

          spec = os.path.join(cli.cmd.path, cli.cmd.spec)

          rpmbuild = ['rpmbuild'] + cli.cmd.rpmdefines + [

              '--nocheck', '--quiet',

              '-bi', spec

          ]

  class TestLocal(CliTestCase):

      create_repo_per_test = False

          cli_cmd = ['rpkg', '--path', self.cloned_repo_path, '--release', 'rhel-6', 'local']

          with patch('sys.argv', new=cli_cmd):

              cli = self.new_cli()

              cli.local()

          spec = os.path.join(cli.cmd.path, cli.cmd.spec)

          rpmbuild = ['rpmbuild'] + cli.cmd.rpmdefines + ['-ba', spec]

          builddir = os.path.join(self.cloned_repo_path, 'this-builddir')

          buildrootdir = os.path.join(self.cloned_repo_path, 'this-buildrootdir')

              '--with', 'a', '--without', 'b', '--buildrootdir', buildrootdir,

              '--', '--clean']

          with patch('sys.argv', new=cli_cmd):

              cli = self.new_cli()

              cli.local()

          spec = os.path.join(cli.cmd.path, cli.cmd.spec)

          rpmbuild = ['rpmbuild'] + cli.cmd.rpmdefines + [

              '--with', 'a', '--without', 'b',

              '--target', 'i686', '--clean', '--quiet',

              '-ba', spec

          ]

  class TestVerifyFiles(CliTestCase):

          spec = os.path.join(cli.cmd.path, cli.cmd.spec)

          rpmbuild = ['rpmbuild'] + cli.cmd.rpmdefines + ['-bl', spec]

      @patch('pyrpkg.Commands._run_command')

      def test_verify_files_with_options(self, _run_command):

          spec = os.path.join(cli.cmd.path, cli.cmd.spec)

          rpmbuild = ['rpmbuild'] + cli.cmd.rpmdefines + [

              '--quiet',

              '-bl', spec

          ]

  class TestVerrel(CliTestCase):

          _run_command.assert_has_calls([

              call(['rpmlint', '--version'], return_stdout=True, return_text=True),

          ])

      @patch('pyrpkg.Commands._run_command')

          _run_command.assert_has_calls([

              call(['rpmlint', '--version'], return_stdout=True, return_text=True),

          ])

      @patch('pyrpkg.Commands._run_command')

          _run_command.assert_has_calls([

              call(['rpmlint', '--version'], return_stdout=True, return_text=True),

          ])

      @patch('pyrpkg.Commands._run_command')

          _run_command.assert_has_calls([

              call(['rpmlint', '--version'], return_stdout=True, return_text=True),

          ])

      @patch('pyrpkg.Commands._run_command')

          _run_command.assert_has_calls([

              call(['rpmlint', '--version'], return_stdout=True, return_text=True),

          ])

      @patch('pyrpkg.Commands._run_command')

          _run_command.assert_has_calls([

              call(['rpmlint', '--version'], return_stdout=True, return_text=True),

          ])

      @patch('pyrpkg.Commands._run_command')

          _run_command.assert_has_calls([

              call(['rpmlint', '--version'], return_stdout=True, return_text=True),

              call(['rpmlint', '-f', custom_lint_config_path,

          ])

              self.assert_option_srpm_use()

          args, kwargs = _run_command.call_args

          rpmbuild_cmd, = args

          self.assertIn('-bs', rpmbuild_cmd)

          self.assertIs(True, self.cmd._uses_rpmautospec)

          self.assertEqual(1, wrapped_popen.call_count)

          args, kwargs = wrapped_popen.call_args

  class LoadBranchMergeTest(CommandTestCase):

          #     '_srcrpmdir': '/path/to/srcrpm-dir',

          #     'dist': 'el7'

          # }

          self.assertEqual(len(expected_defines), len(defines))

          for var, val in expected_defines.items():

          cmd = self.make_commands(path=self.cloned_repo_path)

          # Repos used for running tests locates in local filesyste, refer to

          # self.repo_path and self.cloned_repo_path.

          cmd.distgit_namespaced = False

          self.assertEqual(str(six.next(git.Repo(self.repo_path).iter_commits())),

      def test_raise_error_if_other_non_no_such_file_dir_error(self):

          with patch('shutil.rmtree',

                     side_effect=OSError((errno.EEXIST), 'error message')):

  class TestConfigMockConfigDir(CommandTestCase):

                     os.path.join(cmd.path, 'docpkg.spec'),

                     srpm_path,

                     bin_path,

      @patch('glob.glob')

      @patch('os.path.exists')

                     os.path.join(cmd.path, 'docpkg.spec'),

                     srpm_path,

                     bin_path,

      @patch('glob.glob')

      @patch('os.path.exists')

                     os.path.join(cmd.path, 'docpkg.spec'),

                     srpm_path,

                     bin_path,

  class TestRunCommand(CommandTestCase):

          Popen.return_value.stdout.read.return_value = 'output'

          result = self.cmd._run_command(

          self.assertEqual((0, 'output', None), result)

          Popen.assert_called_once_with(

              stdout=subprocess.PIPE, stderr=None, universal_newlines=False)

      @patch('subprocess.Popen')

          Popen.return_value.stderr.read.return_value = 'output'

          result = self.cmd._run_command(

          self.assertEqual((0, None, 'output'), result)

          Popen.assert_called_once_with(

              stdout=None, stderr=subprocess.PIPE, universal_newlines=False)

      @patch('subprocess.Popen')

      def test_run_command_in_a_directory(self, Popen):

          Popen.return_value.wait.return_value = 0

          Popen.assert_called_once_with(

              stdout=None, stderr=None, universal_newlines=False)

      @patch('subprocess.Popen')

      def test_return_output_as_text(self, Popen):

          Popen.return_value.wait.return_value = 0

      def redirect_cmd_output(self, cmd, shell=False, env=None, pipe=[], cwd=None):

          if shell:

          proc_env = os.environ.copy()

          proc_env.update(env or {})

          proc_env['LANG'] = 'en_US.UTF-8'

                                  stdout=subprocess.PIPE, stderr=subprocess.PIPE)

          stdout, stderr = proc.communicate()

          sys.stdout.write(stdout)