@staticmethod

      def process_on_demand_rules(rules):

          """

          Validates rules and creates objects for them.

                  processed_rules.append(RemoteRule())

              elif rule['type'] == 'PassingTestCaseRule':

                  temp_rule = PassingTestCaseRule()

                  processed_rules.append(temp_rule)

              else:

                  raise BadRequest('Invalid rule type {}'.format(rule['type']))

                      visited_arch_variants.add(arch_variant)

                      answer = self._answer_for_result(

                          result,

                          policy.subject_type,

                          subject_identifier)

                      answers.append(answer)

          for result in matching_results:

              answers.append(self._answer_for_result(

                  result,

                  policy.subject_type,

                  subject_identifier))

          return answers

          }

      def _answer_for_result(

          if result['outcome'] in ('PASSED', 'INFO'):

              log.debug('Test result passed for the result_id %s and testcase %s,'

                        ' because the outcome is %s', result['id'], self.test_case_name,

          policy.relevance_key = data_dict.get('relevance_key')

          # Validate the data before processing.

          return policy

      def __validate_attributes(self):

  import requests

  from requests.adapters import HTTPAdapter

  from requests.packages.urllib3.util.retry import Retry

  from greenwave import __version__

      cmd = ['git', 'archive', f'--remote={dist_git_url}', rev, 'gating.yaml']

      # Retry thrice if TimeoutExpired exception is raised

      MAX_RETRY = 3

          try:

              git_archive = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

              output, error_output = git_archive.communicate(timeout=30)

  def test_make_decision_retrieves_waivers_on_missing(mock_results, mock_waivers):

      response = make_decision()

      assert 200 == response.status_code

      assert '1 of 1 required test results missing' == response.json['summary']

  def test_make_decision_retrieves_waivers_on_failed(mock_results, mock_waivers):

      mock_results.return_value = [make_result(outcome='FAILED')]

      response = make_decision()

      assert 200 == response.status_code

      assert '1 of 1 required tests failed' == response.json['summary']

  def test_make_decision_retrieves_waivers_omitted_on_passed(mock_results, mock_waivers):

      mock_results.return_value = [make_result(outcome='PASSED')]

      response = make_decision()

      assert 200 == response.status_code

      assert 'All required tests passed' == response.json['summary']

  def test_make_decision_retrieves_waivers_once_on_verbose_and_missing(mock_results, mock_waivers):

      response = make_decision(verbose=True)

      assert 200 == response.status_code

      assert '1 of 1 required test results missing' == response.json['summary']

              scm.return_value = (namespace, 'nethack', 'c3c47a08a66451cb9686c49f040776ed35a0d1bb')

              with mock.patch('greenwave.resources.retrieve_yaml_remote_rule') as f:

                  f.return_value = remote_fragment

                  # Ensure that presence of a result is success.

                  results = DummyResultsRetriever(nvr, 'dist.upgradepath')

  def test_guess_product_version():

      hub = mock.MagicMock()

      hub.config = {

          'environment': 'environment',

  def test_guess_product_version_with_koji():

      class DummyKojiProxy():

          def getBuild(self, subject_identifier):

              assert 'fake_koji_build' == subject_identifier

      'badnvr-1.2.f30',

  ))

  def test_guess_product_version_failure(nvr):

      product_version = greenwave.consumers.resultsdb._subject_product_version(nvr, 'koji_build')

      assert product_version is None

  def test_waivers_retriever_retrieves_not_ignored_ids():

      retriever = WaiversRetriever(**_DUMMY_RETRIEVER_ARGUMENTS)

      retriever.ignore_ids = [100]

      waiver = dict(

  def test_waivers_retriever_ignores_ids():

      retriever = WaiversRetriever(**_DUMMY_RETRIEVER_ARGUMENTS)

      retriever.ignore_ids = [99]

      waiver = dict(

  def test_waivers_retriever_ignores_no_waived():

      retriever = WaiversRetriever(**_DUMMY_RETRIEVER_ARGUMENTS)

      waiver = dict(

          id=99,

  [MESSAGES CONTROL]