foreman_leapp 3.4.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7e5030bef562d53e8f4212fa76732f0901ec4b827620a5f07028fd11bcf36d4
-  data.tar.gz: eac05d03ce3b746a996751d2b5affb5ea1fabea4d74dd8899f5771b5bc69f8ec
+  metadata.gz: 51cdabcb8df392e354e77bbe82ab0e3fc4d2c62d993a129668b9367a78453eb7
+  data.tar.gz: ca1c8c041d52581f987d5a3d1a964ff3aeea89290000e0faf55488bd6b4f4a82
 SHA512:
-  metadata.gz: 77e129433f0175d3951ccc870e66bda4f37930d888a83704142e80d95490e7a9c76b134ab3337c293e03c15bc9c770e8835ba9bec8e11e32d66087ff0a23a5a4
-  data.tar.gz: 29c9135b5faf4f6564c71d24cc989a6adc3d4a67c731a5bfca38d3618ec75745f9f1492295356386a7204971d53853558bf5a6d335f5252f55bc0d557bb42f7d
+  metadata.gz: eadf4d4d462b5fa9a9c838946ccca5a7a764e3bcb97f0ee457682f5d43c24a239f9900986d0c088dacb1c51b9d62e1d2800e1b7c2147debf86f465e7fe82bf6c
+  data.tar.gz: 8abd151cbd535508601fda873b41b74548055420d8d1cad40454d3f47cfa0761de40bca70ca91474993a8583be174fac6395e66ef69a5c334f93bb131e31f69a

data/app/controllers/api/v2/preupgrade_report_entries_controller.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Api
+  module V2
+    class PreupgradeReportEntriesController < ::Api::V2::BaseController
+      include ApiAuthorizer
+      include Foreman::Controller::AutoCompleteSearch
+
+      skip_before_action :store_redirect_to_url, :reset_redirect_to_url, raise: false
+      before_action :find_preupgrade_report, if: -> { params[:preupgrade_report_id].present? }
+
+      api :GET, '/preupgrade_reports/:preupgrade_report_id/preupgrade_report_entries',
+        N_('List entries for a specific preupgrade report')
+      api :GET, '/preupgrade_report_entries', N_('List all preupgrade report entries')
+      param :preupgrade_report_id, :identifier, required: false,
+        desc: N_('ID of the preupgrade report')
+      param_group :search_and_pagination, ::Api::V2::BaseController
+      def index
+        @total = resource_scope.count
+        @preupgrade_report_entries = resource_scope_for_index
+        @subtotal = @preupgrade_report_entries.total_entries
+      end
+
+      api :GET, '/preupgrade_report_entries/auto_complete_search',
+        N_('Search autocomplete for preupgrade report entries')
+      param :search, String, required: false, desc: N_('Search string')
+      param :preupgrade_report_id, :identifier, required: false, desc: N_('ID of the preupgrade report')
+
+      api :POST, '/preupgrade_reports/:preupgrade_report_id/preupgrade_report_entries/bulk_remediate',
+        N_('Trigger a remediation job for selected preupgrade report entries')
+      param :search, String, required: false, desc: N_('Search string')
+      param :excluded_ids, Array, required: false, desc: N_('Array of excluded entry IDs')
+      def bulk_remediate
+        entries = filtered_remediation_entries
+        remediation_ids = entries.pluck(:id)
+
+        if remediation_ids.empty?
+          return render json: { error: _('No fixable entries found matching the selection.') },
+            status: :unprocessable_entity
+        end
+
+        composer = JobInvocationComposer.for_feature(
+          'leapp_remediation_plan',
+          target_host_ids(entries),
+          { 'remediation_ids' => remediation_ids.join(',') }
+        )
+        composer.trigger!
+        job_invocation = composer.job_invocation
+
+        render json: { id: job_invocation.id }
+      rescue StandardError => e
+        Foreman::Logging.exception('Failed to trigger bulk remediation job', e)
+        render json: { error: _('An unexpected error occurred while creating the remediation job.') },
+          status: :internal_server_error
+      end
+
+      protected
+
+      def model_of_controller
+        PreupgradeReportEntry
+      end
+
+      def resource_scope(_options = {})
+        scope = if @preupgrade_report
+                  @preupgrade_report.preupgrade_report_entries
+                else
+                  PreupgradeReportEntry
+                end
+        scope.joins(:host).merge(Host.authorized(:view_hosts, Host))
+      end
+
+      def resource_scope_for_index(options = {})
+        order_str = params[:order].to_s
+        return super unless order_str.match?(/^(severity|risk_factor)\b/i)
+        direction = order_str.match?(/desc$/i) ? 'DESC' : 'ASC'
+
+        resource_scope(options)
+          .search_for(params[:search].to_s)
+          .order_by_severity(direction)
+          .paginate(paginate_options)
+      end
+
+      private
+
+      def filtered_remediation_entries
+        combined_search = [params[:search].presence, 'fix_type = command'].compact.join(' AND ')
+        entries = resource_scope.search_for(combined_search)
+        entries = entries.where.not(id: params[:excluded_ids]) if params[:excluded_ids].present?
+        entries
+      end
+
+      def target_host_ids(entries)
+        host_ids = entries.pluck(:host_id).uniq.compact
+        host_ids = [@preupgrade_report.host_id].compact if host_ids.empty? && @preupgrade_report
+        host_ids
+      end
+
+      def find_preupgrade_report
+        @preupgrade_report = PreupgradeReport
+                             .joins(:host)
+                             .merge(Host.authorized(:view_hosts, Host))
+                             .find(params[:preupgrade_report_id])
+      end
+
+      def path_to_authenticate
+        auth_action = case action_name
+                      when 'auto_complete_search'
+                        'index'
+                      when 'bulk_remediate'
+                        'create'
+                      else
+                        action_name
+                      end
+        path_params = params.slice(:id, :user_id)
+                            .merge(action: auth_action, controller: 'api/v2/job_invocations')
+        Foreman::AccessControl.normalize_path_hash(path_params)
+      end
+    end
+  end
+end

data/app/controllers/api/v2/preupgrade_reports_controller.rb

@@ -30,8 +30,8 @@ module Api
       # By overriding path_to_authenticate we can require REX's permission view_job_invocations
       def path_to_authenticate
         params['action'] = 'show' if params['action'] == 'job_invocation'
-        Foreman::AccessControl.normalize_path_hash params.slice(:action, :id, :user_id)
-                                                         .merge({ controller: 'api/v2/job_invocations' })
+        path_params = params.slice(:action, :id, :user_id).merge(controller: 'api/v2/job_invocations')
+        Foreman::AccessControl.normalize_path_hash(path_params)
       end
     end
   end

data/app/models/preupgrade_report_entry.rb

@@ -8,9 +8,81 @@ class PreupgradeReportEntry < ApplicationRecord
   serialize :flags, Array
   serialize :detail, JSON
 
-  validates :preupgrade_report, :host, :hostname, :title, :actor, :audience, :severity, :leapp_run_id, presence: true
+  validates :preupgrade_report, :host, :hostname, :title, :actor,
+    :audience, :severity, :leapp_run_id, presence: true
+
+  scoped_search on: :title, complete_value: true
+  scoped_search on: :hostname, complete_value: true
+  scoped_search on: :summary
+
+  scoped_search on: :severity,
+    rename: :risk_factor,
+    complete_value: { high: 'high', medium: 'medium', low: 'low', info: 'info' }
+
+  scoped_search on: :flags,
+    rename: :inhibitor,
+    only_explicit: true,
+    operators: ['=', '!='],
+    complete_value: { yes: 'yes', no: 'no' },
+    ext_method: :search_yes_no_fields
+
+  scoped_search on: :detail,
+    rename: :has_remediation,
+    only_explicit: true,
+    operators: ['=', '!='],
+    complete_value: { yes: 'yes', no: 'no' },
+    ext_method: :search_yes_no_fields
+
+  scoped_search on: :detail,
+    rename: :fix_type,
+    only_explicit: true,
+    operators: ['=', '!='],
+    complete_value: { hint: 'hint', command: 'command' },
+    ext_method: :search_fix_type
+
+  # info(1) < low(2) < medium(3) < high(4)
+  scope :order_by_severity, lambda { |direction = 'ASC'|
+    dir = direction.to_s.casecmp('DESC').zero? ? 'DESC' : 'ASC'
+    order(Arel.sql(
+      "CASE preupgrade_report_entries.severity " \
+      "WHEN 'high' THEN 4 WHEN 'medium' THEN 3 " \
+      "WHEN 'low' THEN 2 WHEN 'info' THEN 1 ELSE 0 END #{dir}"
+    ))
+  }
 
   def self.remediation_details(remediation_ids, host)
     where(id: remediation_ids, host: host).where.not(detail: nil).pluck(:detail)
   end
+
+  def self.search_yes_no_fields(key, operator, value)
+    column, term = case key.to_sym
+                   when :inhibitor       then %w[flags inhibitor]
+                   when :has_remediation then %w[detail remediations]
+                   else raise Foreman::Exception,
+                     N_("Unknown search key '%s' for search_yes_no_fields") % key
+                   end
+
+    if (operator == '=' && value == 'yes') || (operator == '!=' && value == 'no')
+      { conditions: "preupgrade_report_entries.#{column} LIKE '%%#{term}%%'" }
+    else
+      { conditions: "(preupgrade_report_entries.#{column} NOT LIKE '%%#{term}%%' OR " \
+                    "preupgrade_report_entries.#{column} IS NULL)" }
+    end
+  end
+
+  def self.search_fix_type(_key, operator, value)
+    unless %w[hint command].include?(value.to_s.downcase)
+      raise Foreman::Exception, N_("Unknown fix_type value '%s' for search_fix_type") % value
+    end
+
+    safe_value = sanitize_sql_like(value.to_s.downcase)
+    like_op    = (operator == '=') ? 'LIKE' : 'NOT LIKE'
+
+    conditions = "(preupgrade_report_entries.detail #{like_op} " \
+                 "'%%\"type\":\"#{safe_value}\"%%' OR " \
+                 "preupgrade_report_entries.detail #{like_op} " \
+                 "'%%\"type\": \"#{safe_value}\"%%')"
+    conditions = "(#{conditions} OR preupgrade_report_entries.detail IS NULL)" if operator == '!='
+    { conditions: conditions }
+  end
 end

data/app/views/api/v2/preupgrade_report_entries/index.json.rabl

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+collection @preupgrade_report_entries
+extends 'api/v2/preupgrade_report_entries/base'

data/app/views/api/v2/preupgrade_reports/show.json.rabl

@@ -1,7 +1,4 @@
-object @preupgrade_report
+# frozen_string_literal: true
 
+object @preupgrade_report
 extends 'api/v2/preupgrade_reports/base'
-
-child :preupgrade_report_entries do
-  extends 'api/v2/preupgrade_report_entries/base'
-end

data/config/routes.rb

@@ -1,12 +1,26 @@
 # frozen_string_literal: true
 
 Rails.application.routes.draw do
-  resources :preupgrade_reports, :only => %i[index]
+  resources :preupgrade_reports, only: %i[index]
 
   namespace :api, defaults: { format: 'json' } do
     scope '(:apiv)', module: :v2, defaults: { apiv: 'v2' }, apiv: /v2/,
-      constraints: ApiConstraints.new( version: 2, default: true) do
-      resources :preupgrade_reports, only: %i[index show]
+      constraints: ApiConstraints.new(version: 2, default: true) do
+      resources :preupgrade_report_entries, only: %i[index] do
+        collection do
+          get :auto_complete_search
+        end
+      end
+
+      resources :preupgrade_reports, only: %i[index show] do
+        resources :preupgrade_report_entries, only: %i[index] do
+          collection do
+            get :auto_complete_search
+            post :bulk_remediate
+          end
+        end
+      end
+
       get 'job_invocations/:id/preupgrade_reports', to: 'preupgrade_reports#job_invocation'
     end
   end

data/lib/foreman_leapp/engine.rb

@@ -17,7 +17,7 @@ module ForemanLeapp
     initializer 'foreman_leapp.register_plugin', before: :finisher_hook do |app|
       app.reloader.to_prepare do
         Foreman::Plugin.register :foreman_leapp do
-          requires_foreman '>= 3.16'
+          requires_foreman '>= 5.0'
           register_gettext
 
           apipie_documented_controllers ["#{ForemanLeapp::Engine.root}/app/controllers/api/v2/*.rb"]

data/lib/foreman_leapp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ForemanLeapp
-  VERSION = '3.4.0'
+  VERSION = '4.1.0'
 end

data/test/functional/api/v2/preupgrade_report_entries_controller_test.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+module Api
+  module V2
+    # rubocop:disable Metrics/ClassLength
+    class PreupgradeReportEntriesControllerTest < ActionController::TestCase
+      setup do
+        @host = FactoryBot.create(:host)
+        @job_invocation = FactoryBot.create(:job_invocation)
+        @report = FactoryBot.create(:preupgrade_report, host: @host, job_invocation: @job_invocation)
+        @entry = FactoryBot.create(:preupgrade_report_entry, host: @host, preupgrade_report: @report)
+      end
+
+      test 'should get :index' do
+        get :index, params: { preupgrade_report_id: @report.id }
+        assert_response :success
+
+        body = JSON.parse(@response.body)
+        assert_not_empty body['results']
+        assert_equal @entry.id, body['results'].first['id']
+        assert_equal 1, body['total']
+        assert_equal 1, body['subtotal']
+      end
+
+      test ':index response includes expected entry fields' do
+        get :index, params: { preupgrade_report_id: @report.id }
+        assert_response :success
+
+        entry_json = JSON.parse(@response.body)['results'].first
+        %w[id title hostname severity host_id preupgrade_report_id flags detail].each do |field|
+          assert entry_json.key?(field), "Expected field '#{field}' to be present"
+        end
+      end
+
+      test ':index returns 404 for non-existent preupgrade_report_id' do
+        get :index, params: { preupgrade_report_id: 0 }
+        assert_response :not_found
+      end
+
+      test ':index does not return entries belonging to a different report' do
+        other_report = FactoryBot.create(:preupgrade_report, host: @host,
+          job_invocation: @job_invocation)
+        other_entry = FactoryBot.create(:preupgrade_report_entry, host: @host,
+          preupgrade_report: other_report)
+
+        get :index, params: { preupgrade_report_id: @report.id }
+        assert_response :success
+
+        ids = JSON.parse(@response.body)['results'].map { |e| e['id'] }
+        assert_includes ids, @entry.id
+        assert_not_includes ids, other_entry.id
+      end
+
+      test ':index supports pagination' do
+        FactoryBot.create_list(:preupgrade_report_entry, 4, host: @host, preupgrade_report: @report)
+
+        get :index, params: { preupgrade_report_id: @report.id, per_page: 2, page: 1 }
+        assert_response :success
+
+        body = JSON.parse(@response.body)
+        assert_equal 2, body['results'].size
+        assert_equal 5, body['total']
+      end
+
+      test ':index second page returns correct entries' do
+        FactoryBot.create_list(:preupgrade_report_entry, 4, host: @host, preupgrade_report: @report)
+
+        get :index, params: { preupgrade_report_id: @report.id, per_page: 2, page: 2 }
+        assert_response :success
+        assert_equal 2, JSON.parse(@response.body)['results'].size
+      end
+
+      test ':index supports search by title' do
+        other = FactoryBot.create(:preupgrade_report_entry, host: @host, preupgrade_report: @report,
+          title: 'Unique xqz title for search test')
+
+        get :index, params: { preupgrade_report_id: @report.id,
+                              search: "title = \"#{other.title}\"" }
+        assert_response :success
+
+        body = JSON.parse(@response.body)
+        assert_equal 1, body['results'].size
+        assert_equal other.id, body['results'].first['id']
+      end
+
+      test ':index supports order parameter' do
+        FactoryBot.create(:preupgrade_report_entry, host: @host,
+          preupgrade_report: @report, title: 'AAAA sorts first')
+        FactoryBot.create(:preupgrade_report_entry, host: @host,
+          preupgrade_report: @report, title: 'ZZZZ sorts last')
+
+        get :index, params: { preupgrade_report_id: @report.id, order: 'title ASC' }
+        assert_response :success
+
+        titles = JSON.parse(@response.body)['results'].map { |e| e['title'] }
+        assert titles.index('AAAA sorts first') < titles.index('ZZZZ sorts last')
+      end
+
+      test ':index supports semantic risk_factor ordering' do
+        FactoryBot.create(:preupgrade_report_entry, host: @host,
+          preupgrade_report: @report, severity: 'high')
+        FactoryBot.create(:preupgrade_report_entry, host: @host,
+          preupgrade_report: @report, severity: 'info')
+
+        get :index, params: { preupgrade_report_id: @report.id, order: 'risk_factor ASC' }
+        assert_response :success
+
+        severities = JSON.parse(@response.body)['results'].map { |e| e['severity'] }
+        assert severities.index('info') < severities.index('high'),
+          "Expected 'info' to sort before 'high' in semantic ASC order"
+      end
+
+      test 'should get :auto_complete_search' do
+        get :auto_complete_search, params: { search: 'title' }
+        assert_response :success
+        assert_kind_of Array, JSON.parse(@response.body)
+      end
+
+      test ':auto_complete_search returns non-blank string suggestions' do
+        get :auto_complete_search, params: { search: '' }
+        assert_response :success
+        results = JSON.parse(@response.body)
+        assert_kind_of Array, results
+        assert results.none?(&:blank?), 'Autocomplete results should not contain blank values'
+      end
+
+      test ':auto_complete_search scopes suggestions to report when preupgrade_report_id given' do
+        get :auto_complete_search,
+          params: { search: '', preupgrade_report_id: @report.id }
+        assert_response :success
+        assert_kind_of Array, JSON.parse(@response.body)
+      end
+
+      context 'with permissions' do
+        setup do
+          @user = FactoryBot.create(:user, admin: false)
+          setup_user('view', 'job_invocations', nil, @user)
+          setup_user('view', 'hosts', nil, @user)
+        end
+
+        test 'should get :index' do
+          get :index, params: { preupgrade_report_id: @report.id }, session: set_session_user(@user)
+          assert_response :success
+          assert_not_empty JSON.parse(@response.body)['results']
+        end
+
+        test 'should get :auto_complete_search' do
+          get :auto_complete_search, params: { search: '' }, session: set_session_user(@user)
+          assert_response :success
+        end
+      end
+
+      context 'without :view_job_invocations' do
+        setup do
+          @user = FactoryBot.create(:user, admin: false)
+          setup_user('view', 'hosts', nil, @user)
+        end
+
+        test 'should not get :index' do
+          get :index, params: { preupgrade_report_id: @report.id }, session: set_session_user(@user)
+          assert_response :forbidden
+          assert_includes JSON.parse(@response.body)['error']['missing_permissions'],
+            'view_job_invocations'
+        end
+
+        test 'should not get :auto_complete_search' do
+          get :auto_complete_search, params: { search: '' }, session: set_session_user(@user)
+          assert_response :forbidden
+          assert_includes JSON.parse(@response.body)['error']['missing_permissions'],
+            'view_job_invocations'
+        end
+      end
+
+      context 'without :view_hosts' do
+        setup do
+          @user = FactoryBot.create(:user, admin: false)
+          setup_user('view', 'job_invocations', nil, @user)
+        end
+
+        test 'should not get :index' do
+          get :index, params: { preupgrade_report_id: @report.id }, session: set_session_user(@user)
+          assert_response :forbidden
+          assert_includes JSON.parse(@response.body)['error']['missing_permissions'], 'view_hosts'
+        end
+
+        test 'should not get :auto_complete_search' do
+          get :auto_complete_search, params: { search: '' }, session: set_session_user(@user)
+          assert_response :forbidden
+          assert_includes JSON.parse(@response.body)['error']['missing_permissions'], 'view_hosts'
+        end
+      end
+
+      context 'POST bulk_remediate' do
+        setup do
+          @host = FactoryBot.create(:host)
+          @report = FactoryBot.create(:preupgrade_report, host: @host)
+
+          # Fixable entries
+          fixable_detail = { 'remediations' => [{ 'type' => 'command', 'context' => ['yum', 'update'] }] }
+          @entry1 = FactoryBot.create(:preupgrade_report_entry,
+            preupgrade_report: @report, host: @host, detail: fixable_detail)
+          @entry2 = FactoryBot.create(:preupgrade_report_entry,
+            preupgrade_report: @report, host: @host, detail: fixable_detail)
+          @entry3 = FactoryBot.create(:preupgrade_report_entry,
+            preupgrade_report: @report, host: @host, detail: fixable_detail)
+
+          @unfixable = FactoryBot.create(:preupgrade_report_entry, preupgrade_report: @report, host: @host, detail: {})
+          @composer = mock('composer')
+          @dummy_job = FactoryBot.create(:job_invocation)
+          @composer.stubs(:trigger!)
+          @composer.stubs(:job_invocation).returns(@dummy_job)
+        end
+
+        test 'triggers job invocation for all fixable entries' do
+          expected_ids = [@entry1.id, @entry2.id, @entry3.id].join(',')
+
+          JobInvocationComposer.expects(:for_feature)
+                               .with('leapp_remediation_plan', [@host.id], { 'remediation_ids' => expected_ids })
+                               .returns(@composer)
+
+          post :bulk_remediate, params: { preupgrade_report_id: @report.id }
+          assert_response :success
+          json = ActiveSupport::JSON.decode(response.body)
+          assert_equal @dummy_job.id, json['id']
+        end
+
+        test 'respects the excluded_ids parameter' do
+          expected_ids = [@entry1.id, @entry3.id].join(',')
+
+          JobInvocationComposer.expects(:for_feature)
+                               .with('leapp_remediation_plan', [@host.id], { 'remediation_ids' => expected_ids })
+                               .returns(@composer)
+
+          post :bulk_remediate, params: {
+            preupgrade_report_id: @report.id,
+            excluded_ids: [@entry2.id],
+          }
+          assert_response :success
+        end
+
+        test 'returns error if no fixable entries match' do
+          JobInvocationComposer.expects(:for_feature).never
+
+          post :bulk_remediate, params: {
+            preupgrade_report_id: @report.id,
+            excluded_ids: [@entry1.id, @entry2.id, @entry3.id],
+          }
+          assert_response :unprocessable_entity
+          json = ActiveSupport::JSON.decode(response.body)
+          assert_equal 'No fixable entries found matching the selection.', json['error']
+        end
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/test/functional/api/v2/preupgrade_reports_controller_test.rb

@@ -22,9 +22,9 @@ module Api
         get :show, params: { id: @report.id }
         assert_response :success
 
-        response = JSON.parse(@response.body)
-        assert_equal response['id'], @report.id
-        assert_not_empty response['preupgrade_report_entries']
+        body = JSON.parse(@response.body)
+        assert_equal @report.id, body['id']
+        assert_nil body['results']
       end
 
       test 'should get :job_invocation' do
@@ -49,7 +49,9 @@ module Api
         test 'should get :show' do
           get :show, params: { id: @report.id }, session: set_session_user(@user)
           assert_response :success
-          assert_equal @report.id, JSON.parse(@response.body)['id']
+          json = ActiveSupport::JSON.decode(@response.body)
+          assert_equal @report.id, json['id']
+          assert_nil json['results']
         end
 
         test 'should get :job_invocation' do
@@ -96,7 +98,7 @@ module Api
           assert_includes JSON.parse(@response.body)['error']['missing_permissions'], 'view_hosts'
         end
 
-        test 'should not get :job_invocation' do
+        test 'should not get :show' do
           get :show, params: { id: @report.id }, session: set_session_user(@user)
           assert_response :forbidden
           assert_includes JSON.parse(@response.body)['error']['missing_permissions'], 'view_hosts'

data/test/models/preupgrade_report_entry_test.rb

@@ -33,4 +33,51 @@ class PreupgradeReportEntryTest < ActiveSupport::TestCase
       assert_equal details.size, 0
     end
   end
+
+  describe 'scoped_search' do
+    it 'filters correctly by has_remediation and inhibitor' do
+      host = FactoryBot.create(:host)
+      report = FactoryBot.create(:preupgrade_report)
+
+      entry1 = FactoryBot.create(:preupgrade_report_entry, preupgrade_report: report, host: host,
+        flags: ['inhibitor'],
+        detail: { 'remediations' => [{ 'type' => 'hint' }] })
+      entry2 = FactoryBot.create(:preupgrade_report_entry, preupgrade_report: report, host: host,
+        flags: [],
+        detail: nil)
+
+      assert_includes PreupgradeReportEntry.search_for('inhibitor = yes'), entry1
+      assert_not_includes PreupgradeReportEntry.search_for('inhibitor = yes'), entry2
+      assert_includes PreupgradeReportEntry.search_for('has_remediation = no'), entry2
+      assert_not_includes PreupgradeReportEntry.search_for('has_remediation = no'), entry1
+    end
+
+    it 'filters correctly by risk_factor (renamed from severity)' do
+      host = FactoryBot.create(:host)
+      report = FactoryBot.create(:preupgrade_report)
+
+      high_entry = FactoryBot.create(:preupgrade_report_entry, preupgrade_report: report,
+        host: host, severity: 'high')
+      info_entry = FactoryBot.create(:preupgrade_report_entry, preupgrade_report: report,
+        host: host, severity: 'info')
+
+      assert_includes PreupgradeReportEntry.search_for('risk_factor = high'), high_entry
+      assert_not_includes PreupgradeReportEntry.search_for('risk_factor = high'), info_entry
+    end
+
+    it 'orders semantically via order_by_severity scope' do
+      host = FactoryBot.create(:host)
+      report = FactoryBot.create(:preupgrade_report)
+      FactoryBot.create(:preupgrade_report_entry, preupgrade_report: report, host: host, severity: 'high')
+      FactoryBot.create(:preupgrade_report_entry, preupgrade_report: report, host: host, severity: 'info')
+      FactoryBot.create(:preupgrade_report_entry, preupgrade_report: report, host: host, severity: 'medium')
+      FactoryBot.create(:preupgrade_report_entry, preupgrade_report: report, host: host, severity: 'low')
+
+      asc = PreupgradeReportEntry.order_by_severity('ASC').map(&:severity)
+      assert_equal %w[info low medium high], asc
+
+      desc = PreupgradeReportEntry.order_by_severity('DESC').map(&:severity)
+      assert_equal %w[high medium low info], desc
+    end
+  end
 end

data/webpack/components/PreupgradeReports/PreupgradeReports.js

@@ -1,5 +1,7 @@
 import React, { useState } from 'react';
-import MessageBox from 'foremanReact/components/common/MessageBox';
+import { Icon } from '@patternfly/react-core';
+import { ExclamationCircleIcon } from '@patternfly/react-icons';
+import EmptyState from 'foremanReact/components/common/EmptyState';
 import { LoadingState, Row } from 'patternfly-react';
 import PropTypes from 'prop-types';
 import { sprintf, translate as __ } from 'foremanReact/common/I18n';
@@ -116,10 +118,15 @@ const withLoadingState = Component => componentProps => {
 
   if (!isEmpty(error)) {
     return (
-      <MessageBox
+      <EmptyState
         key="preupgrade-reports-error"
-        icontype="error-circle-o"
-        msg={sprintf(__('Could not retrieve data: %(status)s - %(msg)s'), {
+        variant="xs"
+        icon={
+          <Icon iconSize="lg">
+            <ExclamationCircleIcon />
+          </Icon>
+        }
+        header={sprintf(__('Could not retrieve data: %(status)s - %(msg)s'), {
           status: error.statusText,
           msg: error.errorMsg,
         })}