config_opts['root'] = '{{ rootdir }}'

  config_opts['isolation'] = '{{ isolation }}'

  {%- endif %}

              comps=args.upload_comps, delete_comps=args.delete_comps,

              additional_packages=args.packages, additional_repos=args.repos,

              bootstrap=args.bootstrap, bootstrap_image=args.bootstrap_image,

          )

          print("Edit chroot operation was successful.")

      parser_modify.add_argument("--auto-prune", choices=["on", "off"],

                                 help="If auto-deletion of project's obsoleted builds should be enabled.\

                                 This option can only be specified by a COPR admin.")

                                 help="Choose the isolation method for running commands in buildroot.")

      parser_modify.add_argument(

                                       help="If you don't need this build for all the project's chroots. You can use it several times for each chroot you need.")

      parser_build_parent.add_argument("--background", dest="background", action="store_true", default=False,

                                       help="Mark the build as a background job. It will have lesser priority than regular builds.")

                                       help="Choose the isolation method for running commands in buildroot.")

      parser_build_parent.add_argument(

                                        help="space separated string of package names to be added to buildroot")

      parser_edit_chroot.add_argument("--repos",

                                        help="space separated string of additional repo urls for chroot")

      parser_edit_chroot.add_argument(

          "--bootstrap",

                         [--unlisted-on-hp {on,off}]

                         [--persistent]

                         [--auto-prune {on,off}]

                         name

  --chroot::

  --auto-prune::

  If backend auto-prunning script should be run for this project. This option can only be specified by a COPR admin.

  name::

  Can be just name of the project or in form username/projectname or @groupname/projectname.

                         [--enable-net {on,off}]

                         [--unlisted-on-hp {on,off}]

                         [--auto-prune {on,off}]

                         name

  Alters only specified project property.

  --auto-prune::

  If backend auto-prunning script should be run for this project. This option can only be specified by a COPR admin.

  name::

  Can be just name of the project or in form username/projectname or @groupname/projectname.

  ~~~~~~~~~~~~~~~~~~~~~~~~~~

  usage: copr-cli build [-h] [-r, --chroot CHROOTS] [--memory MEMORY] [--timeout TIMEOUT] [--nowait]

                        copr_repo PKG [PKG ...]

  -r, --chroot::

  --background::

  Run the build at a lower priority.

  copr_repo::

  The copr repository to build the package in. This can be a simple name of some of

  your projects or it can be specified fully as username/project or @groupname/project.

  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  usage: copr edit-chroot [-h] [--upload-comps FILEPATH | --delete-comps]

                          coprchroot

  Edit the specified coprchroot.

  --repos REPOS::

  space separated string of additional repo urls for chroot (e.g. "http://foo http://bar")

  `copr-cli get-chroot coprchroot`

  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

      assert stdout == "New project was successfully created.\n"

  @mock.patch('copr.v3.proxies.project.ProjectProxy.add')

  @mock.patch('copr_cli.main.config_from_file', return_value=mock_config)

  def test_create_multilib_project(config_from_file, project_proxy_add, capsys):

              'chroots': None,

              'background': False,

              'progress_callback': None,

          },

          'packagename': 'test',

          'distgit': None,

                  "chroots": ['fedora-rawhide-x86_64'],

                  "background": True,

                  "progress_callback": None,

              },

          })

          assert call[1] == result

              "use_bootstrap_container": False,

              "with_opts": [],

              "without_opts":[],

          })

      @pytest.yield_fixture

              "config_opts['root'] = 'test-test_fedora-rawhide-x86_64'\n",

              "")

          config = self.get_build_config_result()

          additional = {

              'id': 'x',

          ('simple', 'simple chroot'),

      ]

          choices.append(("unchanged", "Use project settings"))

      choices.extend(default_choices)

      bootstrap = create_mock_bootstrap_field("chroot")

      bootstrap_image = create_mock_bootstrap_image_field()

      def validate(self, *args, **kwargs):  # pylint: disable=signature-differs

          """ We need to special-case custom_image configuration """

              'chroot': chroot_id,

              'with_opts': chroot.with_opts.split(),

              'without_opts': chroot.without_opts.split(),

          }

          config_dict.update(chroot.bootstrap_setup)

          return config_dict

          if build.isolation_set:

              isolation["isolation"] = build.isolation

          return isolation

      @classmethod

      @classmethod

      def add(cls, user, name, selected_chroots, repos=None, description=None,

              instructions=None, check_for_duplicates=False, group=None, persistent=False,

              **kwargs):

          if not flask.g.user.admin and flask.g.user != user:

                             persistent=persistent,

                             auto_prune=auto_prune,

                             bootstrap=bootstrap,

                             follow_fedora_branching=follow_fedora_branching,

                             **kwargs)

      def create_chroot(cls, user, copr, mock_chroot, buildroot_pkgs=None, repos=None, comps=None, comps_name=None,

                        with_opts="", without_opts="",

                        delete_after=None, delete_notify=None, module_toggle="",

          """

          :type user: models.User

          :type mock_chroot: models.MockChroot

          chroot = models.CoprChroot(copr=copr, mock_chroot=mock_chroot)

          cls._update_chroot(buildroot_pkgs, repos, comps, comps_name, chroot,

                             with_opts, without_opts, delete_after, delete_notify,

          # reassign old build_chroots, if the chroot is re-created

          get_old = logic.builds_logic.BuildChrootsLogic.by_copr_and_mock_chroot

      @classmethod

      def update_chroot(cls, user, copr_chroot, buildroot_pkgs=None, repos=None, comps=None, comps_name=None,

                        with_opts="", without_opts="", delete_after=None, delete_notify=None, module_toggle="",

          """

          :type user: models.User

          :type copr_chroot: models.CoprChroot

          cls._update_chroot(buildroot_pkgs, repos, comps, comps_name,

                             copr_chroot, with_opts, without_opts, delete_after, delete_notify, module_toggle,

          return copr_chroot

      @classmethod

      def _update_chroot(cls, buildroot_pkgs, repos, comps, comps_name,

                         copr_chroot, with_opts, without_opts, delete_after, delete_notify, module_toggle,

          if buildroot_pkgs is not None:

              copr_chroot.buildroot_pkgs = buildroot_pkgs

          if bootstrap is not None:

              copr_chroot.bootstrap = bootstrap

          if bootstrap_image is not None:

              # By CLI/API we can set custom_image, and keep bootstrap unset.  In

              # such case set also bootstrap to correct value.

      bootstrap = db.Column(db.Text)

      bootstrap_image = db.Column(db.Text)

      def update_comps(self, comps_xml):

          if isinstance(comps_xml, str):

              data = comps_xml.encode("utf-8")

              return {}

          return settings

  class BuildChroot(db.Model, helpers.Serializer):

      """

      Representation of Build<->MockChroot relation

      {{ render_bootstrap_options(form) }}

      <div class="form-group">

        <label class="col-sm-2 control-label" for="textInput-markup">

          comps.xml

      if not flask.g.user.can_build_in(copr):

          raise AccessRestricted("User {} is not allowed to build in the copr: {}"

                                 .format(flask.g.user.username, copr.full_name))

      generic_build_options = {

          'chroot_names': form.selected_chroots,

          "with_opts": str_to_list(project_chroot.with_opts),

          "without_opts": str_to_list(project_chroot.without_opts),

          "delete_after_days": project_chroot.delete_after_days,

      }

          "enable_net": project_chroot.copr.enable_net,

          "with_opts":  str_to_list(project_chroot.with_opts),

          "without_opts": str_to_list(project_chroot.without_opts),

      }

      for option in ['bootstrap', 'bootstrap_image']:

          if option in config:

          flask.g.user, chroot, buildroot_pkgs, repos, comps=comps_xml, comps_name=comps_name,

          with_opts=with_opts, without_opts=without_opts,

          bootstrap=form.bootstrap.data,

      db.session.commit()

      return flask.jsonify(to_dict(chroot))

                              module_toggle=chroot.module_toggle, with_opts=chroot.with_opts,

                              without_opts=chroot.without_opts,

                              bootstrap=chroot.bootstrap,

      return render_chroot_edit(form, copr, chroot)

                  module_toggle=form.module_toggle.data,

                  bootstrap=form.bootstrap.data,

                  bootstrap_image=form.bootstrap_image.data,

              )

          elif action == "delete_comps":

          raise NotImplementedError

      def edit_chroot(self, project, chroot, bootstrap=None,

          """ Modify CoprChroot """

          raise NotImplementedError

          return resp

      def edit_chroot(self, project, chroot, bootstrap=None,

          """ Change CoprChroot using the web-UI """

          route = "/coprs/{user}/{project}/update_chroot/{chroot}/".format(

              user=owner or self.transaction_username,

              data["bootstrap"] = bootstrap

          if bootstrap_image is not None:

              data["bootstrap_image"] = bootstrap_image

          resp = self.client.post(route, data=data)

          if self.success_expected:

          return resp

      def edit_chroot(self, project, chroot, bootstrap=None,

          route = "/api_3/project-chroot/edit/{owner}/{project}/{chroot}".format(

              owner=owner or self.transaction_username,

              project=project,

              data["bootstrap"] = bootstrap

          if bootstrap_image is not None:

              data["bootstrap_image"] = bootstrap_image

          resp = self.post(route, data)

          return resp

          timeout = buildopts.get("timeout")

          if timeout:

              assert build.timeout == timeout

      @pytest.mark.usefixtures("f_users", "f_users_api", "f_coprs",

                               "f_mock_chroots", "f_other_distgit", "f_db")

          route = "/coprs/{}/{}/edit_chroot/{}/".format(

              self.transaction_username, project, chroot,

          )

              soup = BeautifulSoup(html, "html.parser")

                      .find("option", attrs={'selected': True}))

          resp = self.test_client.get(route)

          self.web_ui.edit_chroot("test", chroot, bootstrap="on")

          resp = self.test_client.get(route)

      @TransactionDecorator("u2")

      @pytest.mark.usefixtures("f_users", "f_users_api", "f_mock_chroots", "f_db")

      "build": "default",

      "expected": "default",

  }, {

      "project": "nspawn",

      "chroot": "fedora-rawhide-i386",

      "build": "simple",

      "expected": "simple",

  }]

  class TestConfigOverrides(CoprsTestCase):

      @pytest.mark.parametrize("request_type", ["api", "webui"])

      @pytest.mark.parametrize("case", VALID_ISOLATION_CONFIG_CASES)

      def test_isolation_override(self, case, request_type):

          client = self.api3 if request_type == "api" else self.web_ui

          client.new_project("test-isolation", [case["chroot"]],

                             isolation=case["project"])

          else:

              assert project.isolation == "default"

          isolation = case["expected"]

          response = self.test_client.get("/backend/get-build-task/1-{}".format(case["chroot"]))

          if not isolation:

              assert "isolation" not in result_dict

          assert result_dict.get("isolation") == isolation

      # pylint: disable=too-many-arguments

      def edit(self, ownername, projectname, chrootname, additional_packages=None, additional_repos=None,

               comps=None, delete_comps=False, with_opts=None, without_opts=None,

          """

          Edit a chroot configuration in a project

          :param str bootstrap: Allowed values 'on', 'off', 'image', 'default',

                                'untouched' (equivalent to None)

          :param str bootstrap_image: Implies 'bootstrap=image'.

          :return: Munch

          """

          endpoint = "/project-chroot/edit/{ownername}/{projectname}/{chrootname}"

              "without_opts": without_opts,

              "bootstrap": bootstrap,

              "bootstrap_image": bootstrap_image,

          }

          files = {}

          if comps: