with open(os.path.join(self.path, 'clog'), 'w') as clog:

              clog.writelines(clog_lines)

          """Run rpmbuild -bc

          Logs the output and returns nothing

          """

              cmd.append("--define '_builddir %s'" % os.path.abspath(builddir))

          if arch:

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

          if short:

              cmd.append('--short-circuit')

          if nocheck:

          # This should have a try and catch koji errors

          self.kojisession.uploadWrapper(file, path, callback=callback)

          """Run ``rpmbuild -bi``

          Logs the output and returns nothing

          :param str arch: specify a specific arch.

          :param bool short: short-circuit it.

          :param str builddir: alternate builddir.

          :param bool nocheck: do not check.

              cmd.append("--define '_builddir %s'" % os.path.abspath(builddir))

          if arch:

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

          if short:

              cmd.append('--short-circuit')

          if nocheck:

          self._run_command(cmd, shell=True)

      def local(self, localargs, arch=None, hashtype=None, builddir=None,

          """rpmbuild locally for given arch.

          Takes localargs (passed to rpmbuild), arch to build for, and hashtype

          `.build-{version}-{release}.log`.

          :param str arch: to optionally build for a specific arch.

          :param str hashtype: an alternative algorithm used for payload file

              digests.

          :param str builddir: an alternative builddir.

                          % hashtype])

          if arch:

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

          if self.quiet:

              cmd.append('--quiet')

          if buildrootdir:

          self.repo.index.add(['sources', '.gitignore'])

          """Run ``rpmbuild -bp``

          :param str arch: optional to run prep section for a specific arch. By

              default, local system arch will be used.

          :param str builddir: an alternative builddir.

          :param str buildrootdir: an alternative buildrootdir.

              cmd.append("--define '_builddir %s'" % os.path.abspath(builddir))

          if arch:

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

          if self.quiet:

              cmd.append('--quiet')

          if buildrootdir:

          # Run the command

          self._run_command(cmd, shell=True)

          """Create an srpm using hashtype from content

          Requires sources already downloaded. The generated SRPM file will be

          :param str hashtype: an alternative algorithm used for payload file

              digests.

          """

          self.srpmname = os.path.join(self.path,

          cmd.extend(self.rpmdefines)

          if self.quiet:

              cmd.append('--quiet')

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

          if not hashtype:

              # Try to determine the dist

                  line_num += 1

          return [line_num, offset - offset_inc + 1]

          """Run `rpmbuild -bl` to verify the `%files` section

          :param str builddir: optionally define an alternate builddir.

          :param str buildrootdir: optionally define an alternate buildrootdir.

          # setup the rpm command

          cmd = ['rpmbuild']

          cmd.extend(self.rpmdefines)

          if builddir:

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

              cmd.append("--define '_builddir %s'" % os.path.abspath(builddir))

              help='Define an alternate buildrootdir')

          self.rpm_parser_common.add_argument(

              '--arch', help='Prep for a specific arch')

      def register_build(self):

          """Register the build target"""

          srpm_parser = self.subparsers.add_parser(

              'srpm', help='Create a source rpm',

              description='Create a source rpm')

          # optionally define old style hashsums

          srpm_parser.add_argument(

          self.sources()

          arch = None

          short = False

          nocheck = False

          if self.args.arch:

              arch = self.args.arch

          if self.args.short_circuit:

              short = True

          if self.args.nocheck:

              nocheck = True

                           builddir=self.args.builddir, nocheck=nocheck)

      def container_build_koji(self):

      def install(self):

          self.sources()

                           short=self.args.short_circuit,

                           builddir=self.args.builddir,

                           nocheck=self.args.nocheck,

          self.cmd.local(localargs,

                         arch=self.args.arch,

                         hashtype=self.args.hash,

                         builddir=self.args.builddir,

                         buildrootdir=self.args.buildrootdir)

      def prep(self):

          self.sources()

                        builddir=self.args.builddir,

                        buildrootdir=self.args.buildrootdir)

      def srpm(self):

          self.sources()

      def switch_branch(self):

          if self.args.branch:

          print('\n'.join(unused))

      def verify_files(self):

                                buildrootdir=self.args.buildrootdir)

      def verrel(self):

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

          _run_command.assert_called_once_with(expected_cmd, shell=True)

  class TestCompile(CliTestCase):

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

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

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

              cli = self.new_cli()

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

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

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

          _run_command.assert_called_once_with(rpmbuild, shell=True)