existing requires on the modulemd. The expected format is ``{'platform': ['f28', 'f29']}``.

  - ``scratch`` - a boolean indicating if a scratch module build should be performed.

    Only allowed to be ``True`` if the MBS setting ``MODULES_ALLOW_SCRATCH`` is ``True``.

  - ``srpms`` - an optional list of Koji upload URLs of SRPMs to include in a module scratch build.

    Only allowed if ``scratch`` is ``True``.

  - ``rebuild_strategy`` - a string of the desired rebuild strategy (affects what components get

  ``submit_module_build(...)``.

  Alternatively, if submitting a YAML modulemd file is allowed (MBS setting

  POST request directly including the contents of a YAML modulemd file

  (called ``yaml``). In this case, the JSON data and YAML file are handled by

  ``views.YAMLFileHandler``, which validates the data and calls the

  to ``submit_module_build(...)``.

  If module scratch builds are allowed (MBS setting ``MODULES_ALLOW_SCRATCH`` is

  via calls to Koji's ``session.uploadWrapper(..)``, and supply the list of

  upload links to MBS (called ``srpms``). Such custom SRPMs will be used to

  override the git repository source for corresponding components.

  from flask import request, url_for

  from flask.views import MethodView

  from six import string_types

  from module_build_service import app, conf, log, models, db, version, api_version as max_api_version

  from module_build_service.utils import (

      # Additional POST and DELETE handlers for modules follow.

      @validate_api_version()

      def post(self, api_version):

          else:

          if conf.no_auth is True and handler.username == "anonymous" and "owner" in handler.data:

              handler.username = handler.data["owner"]

          try:

              r = json.loads(request.get_data().decode("utf-8"))

          except Exception:

              raise ValidationError('Invalid JSON submitted')

          if "owner" in r:

  class BaseHandler(object):

          self.username, self.groups = module_build_service.auth.get_user(request)

          # canonicalize and validate scratch option

          if 'scratch' in self.data and str_to_bool(str(self.data['scratch'])):

      @property

      def optional_params(self):

      def _validate_dep_overrides_format(self, key):

          """

      def validate_optional_params(self):

          module_build_columns = set([col.key for col in models.ModuleBuild.__table__.columns])

          other_params = set([

          valid_params = other_params | module_build_columns

          forbidden_params = [k for k in self.data if k not in valid_params]

  class YAMLFileHandler(BaseHandler):

          if not self.data['scratch'] and not conf.yaml_submit_allowed:

              raise Forbidden("YAML submission is not enabled")

      def validate(self):

              log.error('Invalid file submitted')

              raise ValidationError('Invalid file submitted')

          self.validate_optional_params()

      def post(self):

          return submit_module_build_from_yaml(self.username, handle,

                                               optional_params=self.optional_params)

  def register_api():

      """ Registers the MBS API. """

      module_view = ModuleBuildAPI.as_view('module_builds')

  import module_build_service.scm

  from mock import patch, PropertyMock

  from shutil import copyfile

  from os import path, mkdir

  from requests.utils import quote

  import hashlib

  import pytest

      @patch('module_build_service.scm.SCM')

      @patch('module_build_service.config.Config.modules_allow_scratch',

             new_callable=PropertyMock, return_value=True)

          FakeSCM(mocked_scm, 'testmodule', 'testmodule.yaml',

                  '620ec77321b2ea7b0d67d82992dda3e1d67055b4')

      @patch('module_build_service.scm.SCM')

      @patch('module_build_service.config.Config.modules_allow_scratch',

             new_callable=PropertyMock, return_value=False)

          FakeSCM(mocked_scm, 'testmodule', 'testmodule.yaml',

                  '620ec77321b2ea7b0d67d82992dda3e1d67055b4')

             new_callable=PropertyMock, return_value=True)

      @patch('module_build_service.config.Config.yaml_submit_allowed',

             new_callable=PropertyMock, return_value=True)

          base_dir = path.abspath(path.dirname(__file__))

          mmd_path = path.join(base_dir, '..', 'staged_data', 'testmodule.yaml')

          post_url = '/module-build-service/{0}/module-builds/'.format(api_version)

          with open(mmd_path, 'rb') as f:

          data = json.loads(rv.data)

          if api_version >= 2:

          mmd_path = path.join(base_dir, '..', 'staged_data', 'testmodule.yaml')

          post_url = '/module-build-service/{0}/module-builds/'.format(api_version)

          with open(mmd_path, 'rb') as f:

          # this test is the same as the previous except YAML_SUBMIT_ALLOWED is False,

          # but it should still succeed since yaml is always allowed for scratch builds

          assert rv.status_code == 201