foreman_openscap 13.0.1 → 13.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31e3721d3419a9695bb06d27b4dc1f79daf7aa825fe091afdd5ce3ab84fec6d5
-  data.tar.gz: '09f41b5c13f636a9227ace3b2e2b7c27f5341d22400d98afdcddc597c5650af6'
+  metadata.gz: 18cf4b07fd89183f5ced6a907f35a88be64e9a19461dfdfc68511d826e42797e
+  data.tar.gz: f581fc51af310ca96c388121914040d7885d2b81d42c14e1982a8efa6501c336
 SHA512:
-  metadata.gz: 508fba001dca06e61ae108a10ca54193eec9ab3ba4f26b310481713a852aef69d09c720fdd44ea8ecf89a741a906c30b415640497894f4e0da92b14f0bb5de15
-  data.tar.gz: ffcc23a0d7bd9ecf624ee81f6e46eadd02fc1bf9111e8bd15648590e9f435a7872e6791f2197d024f680628bdf9de5f6e602c5b13f156984130b2865ad381d34
+  metadata.gz: c1c1b44af883638d4bd5c3991dbd40e6ac18d49d85089726d43eca66802727ee91716e2abe3161b5348452e52e8ee97dbd404508381c05482d57dbf10be141d1
+  data.tar.gz: 8c3296b8ac590c9da6323a9fc7cff8d4f73a2b0a258bb5bcb3cda6efc6cedc416c66494590987e2893a499fb64be8d44a1c79b214a581fb907758e4751f69971

data/app/controllers/api/v2/compliance/hosts_bulk_actions_controller.rb

@@ -0,0 +1,89 @@
+module Api::V2
+  module Compliance
+    class HostsBulkActionsController < ::Api::V2::BaseController
+      include Api::V2::BulkHostsExtension
+
+      rescue_from ActionController::ParameterMissing do |exception|
+        render_error(:custom_error, :status => :unprocessable_entity, :locals => { :message => exception.message })
+      end
+
+      before_action :find_editable_hosts, only: [:change_openscap_proxy]
+      before_action :find_openscap_proxy, only: [:change_openscap_proxy]
+      before_action :validate_openscap_proxy_feature, only: [:change_openscap_proxy]
+
+      def_param_group :bulk_host_ids do
+        param :included, Hash, :desc => N_("Hosts to include in the action"), :required => true, :action_aware => true do
+          param :search, String, :required => false, :desc => N_("Search string describing which hosts to perform the action on")
+          param :ids, Array, :required => false, :desc => N_("List of host ids to perform the action on")
+        end
+        param :excluded, Hash, :desc => N_("Hosts to explicitly exclude in the action."\
+                                           " All other hosts will be included in the action,"\
+                                           " unless an included parameter is passed as well."), :required => true, :action_aware => true do
+          param :ids, Array, :required => false, :desc => N_("List of host ids to exclude and not perform the action on")
+        end
+      end
+
+      api :PUT, "/hosts/bulk/change_openscap_proxy", N_("Assign OpenSCAP Proxy to multiple hosts")
+      param_group :bulk_host_ids
+      param :openscap_proxy_id, :number, :required => true, :desc => N_("ID of the OpenSCAP Proxy to assign to the hosts")
+      def change_openscap_proxy
+        failed_host_ids = []
+        host_count = @hosts.count
+
+        @hosts.find_each do |host|
+          host.openscap_proxy = @smart_proxy
+          failed_host_ids << host.id unless host.save
+        end
+
+        if failed_host_ids.empty?
+          message = _("OpenSCAP Proxy is set to %s") % @smart_proxy.name
+          process_response(true, {
+            :message => n_("Updated host: #{message}", "Updated hosts: #{message}", host_count),
+          })
+        else
+          failed_count = failed_host_ids.size
+          success_count = host_count - failed_count
+
+          parts = [
+            n_("Failed to assign OpenSCAP Proxy to %{failed} of %{total} host.",
+               "Failed to assign OpenSCAP Proxy to %{failed} of %{total} hosts.",
+               host_count) % { failed: failed_count, total: host_count },
+          ]
+          if success_count > 0
+            parts << n_("Successfully updated %{success} host.",
+                        "Successfully updated %{success} hosts.",
+                        success_count) % { success: success_count }
+          end
+
+          render_error(:bulk_hosts_error, :status => :unprocessable_entity,
+                       :locals => {
+                         :message => parts.join(' '),
+                         :failed_host_ids => failed_host_ids,
+                       })
+        end
+      end
+
+      private
+
+      def find_editable_hosts
+        find_bulk_hosts(:edit_hosts, params)
+      end
+
+      def find_openscap_proxy
+        @smart_proxy = ::SmartProxy.authorized(:view_smart_proxies)
+          .find_by(:id => params.require(:openscap_proxy_id))
+        return if @smart_proxy
+
+        render_error(:custom_error, :status => :unprocessable_entity,
+                     :locals => { :message => _("OpenSCAP Proxy with id %s not found") % params[:openscap_proxy_id] })
+      end
+
+      def validate_openscap_proxy_feature
+        return if @smart_proxy.has_feature?('Openscap')
+
+        render_error(:custom_error, :status => :unprocessable_entity,
+                     :locals => { :message => _("The selected OpenSCAP Proxy does not have the OpenSCAP feature enabled.") })
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -103,6 +103,8 @@ Rails.application.routes.draw do
           end
         end
       end
+
+      match 'hosts/bulk/change_openscap_proxy', :to => 'compliance/hosts_bulk_actions#change_openscap_proxy', :via => [:put]
     end
   end
 end

data/lib/foreman_openscap/engine.rb

@@ -93,7 +93,8 @@ module ForemanOpenscap
                       :resource_type => 'ForemanOpenscap::ScapContent'
             permission :edit_hosts, { :hosts => %i[openscap_proxy_changed
                                                   select_multiple_openscap_proxy
-                                                  update_multiple_openscap_proxy] },
+                                                  update_multiple_openscap_proxy],
+                                      'api/v2/compliance/hosts_bulk_actions' => [:change_openscap_proxy] },
                       :resource_type => "Host"
             permission :view_hosts, { 'api/v2/hosts' => [:policies_enc] }, :resource_type => 'Host'
             permission :edit_hostgroups, { :hostgroups => [:openscap_proxy_changed] }, :resource_type => "Hostgroup"

data/lib/foreman_openscap/version.rb

@@ -1,3 +1,3 @@
 module ForemanOpenscap
-  VERSION = "13.0.1".freeze
+  VERSION = '13.1.0'.freeze
 end

data/test/functional/api/v2/compliance/hosts_bulk_actions_controller_test.rb

@@ -0,0 +1,132 @@
+require 'test_plugin_helper'
+
+class Api::V2::Compliance::HostsBulkActionsControllerTest < ActionController::TestCase
+  tests Api::V2::Compliance::HostsBulkActionsController
+
+  def setup
+    as_admin do
+      @organization = FactoryBot.create(:organization)
+      @location = FactoryBot.create(:location)
+      @proxy = FactoryBot.create(:openscap_proxy,
+                                 :organizations => [@organization],
+                                 :locations => [@location])
+      @host1 = FactoryBot.create(:host, :managed,
+                                 :organization => @organization,
+                                 :location => @location)
+      @host2 = FactoryBot.create(:host, :managed,
+                                 :organization => @organization,
+                                 :location => @location)
+      @host_ids = [@host1.id, @host2.id]
+    end
+  end
+
+  def valid_bulk_params(host_ids = @host_ids)
+    {
+      :organization_id => @organization.id,
+      :location_id => @location.id,
+      :included => {
+        :ids => host_ids,
+      },
+      :excluded => {
+        :ids => [],
+      },
+    }
+  end
+
+  test "should assign openscap proxy to selected hosts" do
+    put :change_openscap_proxy,
+        params: valid_bulk_params.merge(:openscap_proxy_id => @proxy.id),
+        session: set_session_user
+
+    assert_response :success
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_match(/Updated hosts: OpenSCAP Proxy is set to/, response['message'])
+    assert_includes response['message'], @proxy.name
+
+    [@host1, @host2].each do |host|
+      host.reload
+      assert_equal @proxy.id, host.openscap_proxy_id
+    end
+  end
+
+  test "should require openscap_proxy_id" do
+    put :change_openscap_proxy,
+        params: valid_bulk_params,
+        session: set_session_user
+
+    assert_response :unprocessable_entity
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_match(/openscap_proxy_id/, response['error']['message'])
+  end
+
+  test "should return error when proxy is not found" do
+    put :change_openscap_proxy,
+        params: valid_bulk_params.merge(:openscap_proxy_id => 0),
+        session: set_session_user
+
+    assert_response :unprocessable_entity
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_match(/OpenSCAP Proxy with id .* not found/, response['error']['message'])
+  end
+
+  test "should return error when proxy lacks Openscap feature" do
+    other_proxy = FactoryBot.create(:smart_proxy,
+                                    :organizations => [@organization],
+                                    :locations => [@location])
+    openscap_feature = Feature.find_by(:name => 'Openscap')
+    other_proxy.features.delete(openscap_feature) if openscap_feature
+    refute other_proxy.reload.has_feature?('Openscap')
+
+    put :change_openscap_proxy,
+        params: valid_bulk_params.merge(:openscap_proxy_id => other_proxy.id),
+        session: set_session_user
+
+    assert_response :unprocessable_entity
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_match(/OpenSCAP Proxy does not have the OpenSCAP feature/, response['error']['message'])
+  end
+
+  test "should assign openscap proxy for a single host" do
+    put :change_openscap_proxy,
+        params: valid_bulk_params([@host1.id]).merge(:openscap_proxy_id => @proxy.id),
+        session: set_session_user
+
+    assert_response :success
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_match(/Updated host: OpenSCAP Proxy is set to/, response['message'])
+
+    @host1.reload
+    assert_equal @proxy.id, @host1.openscap_proxy_id
+    @host2.reload
+    assert_nil @host2.openscap_proxy_id
+  end
+
+  test "should report failed and successful counts on partial failure" do
+    Host.any_instance.stubs(:save).returns(false).then.returns(true)
+
+    put :change_openscap_proxy,
+        params: valid_bulk_params.merge(:openscap_proxy_id => @proxy.id),
+        session: set_session_user
+
+    assert_response :unprocessable_entity
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_match(/Failed to assign OpenSCAP Proxy to 1 of 2 hosts/, response['error']['message'])
+    assert_match(/Successfully updated 1 host/, response['error']['message'])
+    assert_equal 1, response['error']['failed_host_ids'].size
+    assert_includes @host_ids, response['error']['failed_host_ids'].first
+  end
+
+  test "should report only failures when all hosts fail" do
+    Host.any_instance.stubs(:save).returns(false)
+
+    put :change_openscap_proxy,
+        params: valid_bulk_params.merge(:openscap_proxy_id => @proxy.id),
+        session: set_session_user
+
+    assert_response :unprocessable_entity
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_match(/Failed to assign OpenSCAP Proxy to 2 of 2 hosts/, response['error']['message'])
+    refute_match(/Successfully updated/, response['error']['message'])
+    assert_equal @host_ids.sort, response['error']['failed_host_ids'].sort
+  end
+end

data/webpack/components/HostsIndex/BulkActions/changeOpenscapProxy/BulkChangeOpenscapProxyModal.js

@@ -0,0 +1,227 @@
+import React, { useState, useEffect } from 'react';
+import PropTypes from 'prop-types';
+import { useDispatch, useSelector } from 'react-redux';
+import {
+  Modal,
+  Button,
+  Grid,
+  GridItem,
+  Form,
+  FormGroup,
+  Stack,
+  StackItem,
+  Skeleton,
+} from '@patternfly/react-core';
+import { SimpleDropdown } from '@patternfly/react-templates';
+import { foremanUrl } from 'foremanReact/common/helpers';
+import { APIActions } from 'foremanReact/redux/API';
+import { sprintf, translate as __ } from 'foremanReact/common/I18n';
+import { STATUS } from 'foremanReact/constants';
+import {
+  selectAPIStatus,
+  selectAPIResponse,
+} from 'foremanReact/redux/API/APISelectors';
+import { buildBulkRequestBody } from 'foremanReact/components/HostsIndex/BulkActions/helpers';
+import {
+  BULK_CHANGE_OPENSCAP_PROXY_KEY,
+  OPENSCAP_PROXIES_KEY,
+} from '../../../OpenscapRemediationWizard/constants';
+
+const fetchOpenscapProxies = () =>
+  APIActions.get({
+    key: OPENSCAP_PROXIES_KEY,
+    url: foremanUrl(
+      '/api/smart_proxies?search=feature%3DOpenscap&per_page=all'
+    ),
+  });
+
+const BulkChangeOpenscapProxyModal = ({
+  isOpen,
+  closeModal,
+  selectAllHostsMode,
+  selectedCount,
+  fetchBulkParams,
+  organizationId,
+  locationId,
+  onSuccess: onSuccessCallback,
+}) => {
+  const dispatch = useDispatch();
+  const [proxyId, setProxyId] = useState('');
+  const [isSubmitting, setIsSubmitting] = useState(false);
+
+  useEffect(() => {
+    if (isOpen) {
+      dispatch(fetchOpenscapProxies());
+    } else {
+      setIsSubmitting(false);
+    }
+  }, [dispatch, isOpen]);
+
+  const proxies = useSelector(state =>
+    selectAPIResponse(state, OPENSCAP_PROXIES_KEY)
+  );
+  const proxyStatus = useSelector(state =>
+    selectAPIStatus(state, OPENSCAP_PROXIES_KEY)
+  );
+
+  const handleModalClose = () => {
+    setProxyId('');
+    setIsSubmitting(false);
+    closeModal();
+  };
+
+  const handleSuccess = () => {
+    handleModalClose();
+    if (onSuccessCallback) onSuccessCallback();
+  };
+
+  const handleError = () => {
+    setIsSubmitting(false);
+    handleModalClose();
+  };
+
+  const handleConfirm = () => {
+    const requestBody = buildBulkRequestBody({
+      fetchBulkParams,
+      organizationId,
+      locationId,
+      openscap_proxy_id: proxyId,
+    });
+
+    setIsSubmitting(true);
+    dispatch(
+      APIActions.put({
+        key: BULK_CHANGE_OPENSCAP_PROXY_KEY,
+        url: foremanUrl('/api/v2/hosts/bulk/change_openscap_proxy'),
+        handleSuccess,
+        successToast: response => response.data.message,
+        handleError,
+        errorToast: error => error?.response?.data?.error?.message,
+        params: requestBody,
+      })
+    );
+  };
+
+  const descriptionText = selectAllHostsMode ? (
+    <>
+      {__('Assign OpenSCAP Proxy for ')}
+      <strong>{__('ALL selected hosts.')}</strong>
+      <br />
+      {__('This will change previous proxy assignments on the selected hosts.')}
+    </>
+  ) : (
+    <>
+      {__('Assign OpenSCAP Proxy for ')}
+      <strong>{sprintf(__('%s selected hosts.'), selectedCount)}</strong>
+      <br />
+      {__('This will change previous proxy assignments on the selected hosts.')}
+    </>
+  );
+
+  const getProxyLabel = id => {
+    const proxy = proxies?.results?.find(
+      p => p.id.toString() === id.toString()
+    );
+    return proxy?.name || id;
+  };
+
+  const proxyItems =
+    proxies?.results?.map(proxy => ({
+      value: proxy.id.toString(),
+      content: proxy.name,
+      onClick: () => setProxyId(proxy.id.toString()),
+    })) || [];
+
+  const modalActions = [
+    <Button
+      key="confirm"
+      ouiaId="bulk-change-openscap-proxy-modal-confirm-button"
+      variant="primary"
+      onClick={handleConfirm}
+      isDisabled={proxyId === '' || isSubmitting}
+      isLoading={isSubmitting}
+      spinnerAriaLabel={__('Loading')}
+    >
+      {__('Assign')}
+    </Button>,
+    <Button
+      key="cancel"
+      ouiaId="bulk-change-openscap-proxy-modal-cancel-button"
+      variant="link"
+      onClick={handleModalClose}
+      isDisabled={isSubmitting}
+    >
+      {__('Cancel')}
+    </Button>,
+  ];
+
+  return (
+    <Modal
+      isOpen={isOpen}
+      onClose={handleModalClose}
+      onEscapePress={handleModalClose}
+      title={__('Assign OpenSCAP Proxy')}
+      variant="small"
+      position="top"
+      actions={modalActions}
+      id="bulk-change-openscap-proxy-modal"
+      key="bulk-change-openscap-proxy-modal"
+      ouiaId="bulk-change-openscap-proxy-modal"
+    >
+      <Stack hasGutter>
+        <StackItem>{descriptionText}</StackItem>
+        {proxyStatus === STATUS.RESOLVED && proxies?.results?.length > 0 && (
+          <StackItem>
+            <Grid>
+              <GridItem span={8}>
+                <Form>
+                  <FormGroup label={__('Select OpenSCAP Proxy')}>
+                    <SimpleDropdown
+                      id="openscap-proxy-select"
+                      ouiaId="bulk-change-openscap-proxy-select"
+                      toggleContent={
+                        proxyId
+                          ? getProxyLabel(proxyId)
+                          : __('Select OpenSCAP Proxy')
+                      }
+                      initialItems={proxyItems}
+                    />
+                  </FormGroup>
+                </Form>
+              </GridItem>
+            </Grid>
+          </StackItem>
+        )}
+        {proxyStatus === STATUS.RESOLVED &&
+          (!proxies?.results || proxies.results.length === 0) &&
+          __(
+            'No OpenSCAP Proxies available. Please configure a Smart Proxy with the OpenSCAP feature.'
+          )}
+        {proxyStatus === STATUS.PENDING && (
+          <Skeleton screenreaderText="Loading contents" />
+        )}
+      </Stack>
+    </Modal>
+  );
+};
+
+BulkChangeOpenscapProxyModal.propTypes = {
+  isOpen: PropTypes.bool,
+  closeModal: PropTypes.func,
+  fetchBulkParams: PropTypes.func.isRequired,
+  selectedCount: PropTypes.number.isRequired,
+  selectAllHostsMode: PropTypes.bool.isRequired,
+  organizationId: PropTypes.number,
+  locationId: PropTypes.number,
+  onSuccess: PropTypes.func,
+};
+
+BulkChangeOpenscapProxyModal.defaultProps = {
+  isOpen: false,
+  closeModal: () => {},
+  organizationId: undefined,
+  locationId: undefined,
+  onSuccess: undefined,
+};
+
+export default BulkChangeOpenscapProxyModal;

data/webpack/components/HostsIndex/BulkActions/changeOpenscapProxy/__tests__/BulkChangeOpenscapProxyModal.test.js

@@ -0,0 +1,198 @@
+import React from 'react';
+import {
+  screen,
+  fireEvent,
+  waitFor,
+  within,
+  act,
+} from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { rtlHelpers, initMockStore } from 'foremanReact/common/testHelpers';
+import { STATUS } from 'foremanReact/constants';
+import { APIActions } from 'foremanReact/redux/API';
+import { OPENSCAP_PROXIES_KEY } from '../../../../OpenscapRemediationWizard/constants';
+import BulkChangeOpenscapProxyModal from '../BulkChangeOpenscapProxyModal';
+
+const { renderWithStore } = rtlHelpers;
+
+jest.mock('foremanReact/common/I18n');
+
+jest.spyOn(APIActions, 'get');
+jest.spyOn(APIActions, 'put');
+
+const proxies = {
+  results: [
+    { id: 1, name: 'openscap-proxy-1.example.com' },
+    { id: 2, name: 'openscap-proxy-2.example.com' },
+  ],
+};
+
+const defaultProps = {
+  selectedCount: 3,
+  selectAllHostsMode: false,
+  fetchBulkParams: jest.fn(() => 'id ^ (1,2,3)'),
+  isOpen: true,
+  closeModal: jest.fn(),
+  organizationId: 1,
+  locationId: 2,
+};
+
+const proxiesResolvedState = {
+  API: {
+    [OPENSCAP_PROXIES_KEY]: {
+      status: STATUS.RESOLVED,
+      response: proxies,
+    },
+  },
+};
+
+const noProxiesState = {
+  API: {
+    [OPENSCAP_PROXIES_KEY]: {
+      status: STATUS.RESOLVED,
+      response: { results: [] },
+    },
+  },
+};
+
+const renderModal = (props = {}, initialState = proxiesResolvedState) =>
+  renderWithStore(
+    <BulkChangeOpenscapProxyModal {...defaultProps} {...props} />,
+    initialState
+  );
+
+describe('BulkChangeOpenscapProxyModal', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // renderWithStore lodash-merges into shared initMockStore; clear prior API fixtures
+    delete initMockStore.API[OPENSCAP_PROXIES_KEY];
+    APIActions.get.mockImplementation(payload => ({
+      type: 'TEST_API_GET',
+      payload,
+    }));
+    APIActions.put.mockImplementation(payload => ({
+      type: 'TEST_API_PUT',
+      payload,
+    }));
+  });
+
+  it('renders modal title and description with selected host count', () => {
+    renderModal();
+    expect(screen.getByText('Assign OpenSCAP Proxy')).toBeInTheDocument();
+    expect(screen.getByText('3 selected hosts.')).toBeInTheDocument();
+  });
+
+  it('renders all-hosts mode description', () => {
+    renderModal({ selectAllHostsMode: true });
+    expect(screen.getByText('ALL selected hosts.')).toBeInTheDocument();
+  });
+
+  it('disables Assign until a proxy is selected', () => {
+    renderModal();
+    expect(screen.getByRole('button', { name: 'Assign' })).toBeDisabled();
+  });
+
+  it('lists OpenSCAP proxies in the dropdown', async () => {
+    renderModal();
+    fireEvent.click(
+      screen.getByRole('button', { name: 'Select OpenSCAP Proxy' })
+    );
+
+    const menu = await screen.findByRole('menu');
+    expect(
+      within(menu).getByRole('menuitem', {
+        name: 'openscap-proxy-1.example.com',
+      })
+    ).toBeInTheDocument();
+    expect(
+      within(menu).getByRole('menuitem', {
+        name: 'openscap-proxy-2.example.com',
+      })
+    ).toBeInTheDocument();
+  });
+
+  it('enables Assign and dispatches bulk PUT after selecting a proxy', async () => {
+    renderModal();
+    fireEvent.click(
+      screen.getByRole('button', { name: 'Select OpenSCAP Proxy' })
+    );
+
+    const menu = await screen.findByRole('menu');
+    fireEvent.click(
+      within(menu).getByRole('menuitem', {
+        name: 'openscap-proxy-1.example.com',
+      })
+    );
+
+    const assignBtn = screen.getByRole('button', { name: 'Assign' });
+    await waitFor(() => {
+      expect(assignBtn).not.toBeDisabled();
+    });
+
+    fireEvent.click(assignBtn);
+    expect(APIActions.put).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: expect.stringContaining('/hosts/bulk/change_openscap_proxy'),
+        params: expect.objectContaining({
+          included: { search: 'id ^ (1,2,3)' },
+          organization_id: 1,
+          location_id: 2,
+          openscap_proxy_id: '1',
+        }),
+      })
+    );
+  });
+
+  it('calls onSuccess and closeModal after a successful bulk PUT', async () => {
+    const onSuccess = jest.fn();
+    const closeModal = jest.fn();
+    renderModal({ onSuccess, closeModal });
+
+    fireEvent.click(
+      screen.getByRole('button', { name: 'Select OpenSCAP Proxy' })
+    );
+
+    const menu = await screen.findByRole('menu');
+    fireEvent.click(
+      within(menu).getByRole('menuitem', {
+        name: 'openscap-proxy-1.example.com',
+      })
+    );
+
+    const assignBtn = screen.getByRole('button', { name: 'Assign' });
+    await waitFor(() => {
+      expect(assignBtn).not.toBeDisabled();
+    });
+
+    fireEvent.click(assignBtn);
+
+    const { handleSuccess } = APIActions.put.mock.calls[0][0];
+    act(() => {
+      handleSuccess();
+    });
+
+    expect(onSuccess).toHaveBeenCalled();
+    expect(closeModal).toHaveBeenCalled();
+  });
+
+  it('calls closeModal on Cancel', () => {
+    const closeModal = jest.fn();
+    renderModal({ closeModal });
+    fireEvent.click(screen.getByRole('button', { name: 'Cancel' }));
+    expect(closeModal).toHaveBeenCalled();
+  });
+
+  it('shows empty state when no proxies are available', () => {
+    renderModal({}, noProxiesState);
+    expect(
+      screen.getByText(
+        'No OpenSCAP Proxies available. Please configure a Smart Proxy with the OpenSCAP feature.'
+      )
+    ).toBeInTheDocument();
+  });
+
+  it('does not render when isOpen is false', () => {
+    renderModal({ isOpen: false });
+    expect(screen.queryByText('Assign OpenSCAP Proxy')).not.toBeInTheDocument();
+  });
+});

data/webpack/components/HostsIndex/ChangeOpenscapProxyAction.js

@@ -0,0 +1,65 @@
+import React, { useContext } from 'react';
+import PropTypes from 'prop-types';
+import { MenuItem } from '@patternfly/react-core';
+import { translate as __ } from 'foremanReact/common/I18n';
+import {
+  openBulkModal,
+  useBulkModalOpen,
+} from 'foremanReact/common/BulkModalStateHelper';
+import { ForemanActionsBarContext } from 'foremanReact/components/HostDetails/ActionsBar';
+import BulkChangeOpenscapProxyModal from './BulkActions/changeOpenscapProxy/BulkChangeOpenscapProxyModal';
+import { CHANGE_OPENSCAP_MODAL_ID } from '../OpenscapRemediationWizard/constants';
+
+export const ChangeOpenscapProxyMenuItem = ({ selectedCount }) => {
+  const openModal = () => openBulkModal(CHANGE_OPENSCAP_MODAL_ID, true);
+
+  return (
+    <MenuItem
+      itemId="change-openscap-proxy-dropdown-item"
+      key="change-openscap-proxy-dropdown-item"
+      onClick={openModal}
+      isDisabled={selectedCount === 0}
+    >
+      {__('OpenSCAP Proxy')}
+    </MenuItem>
+  );
+};
+
+ChangeOpenscapProxyMenuItem.propTypes = {
+  selectedCount: PropTypes.number,
+};
+
+ChangeOpenscapProxyMenuItem.defaultProps = {
+  selectedCount: 0,
+};
+
+const BulkChangeOpenscapProxyModalScene = () => {
+  const {
+    selectAllHostsMode = false,
+    selectedCount = 0,
+    fetchBulkParams,
+    organizationId,
+    locationId,
+    refreshTableData,
+  } = useContext(ForemanActionsBarContext) || {};
+
+  const { isOpen, close: closeModal } = useBulkModalOpen(
+    CHANGE_OPENSCAP_MODAL_ID
+  );
+
+  return (
+    <BulkChangeOpenscapProxyModal
+      key="bulk-change-openscap-proxy-modal"
+      selectAllHostsMode={selectAllHostsMode}
+      selectedCount={selectedCount}
+      fetchBulkParams={fetchBulkParams}
+      organizationId={organizationId}
+      locationId={locationId}
+      isOpen={isOpen}
+      closeModal={closeModal}
+      onSuccess={refreshTableData}
+    />
+  );
+};
+
+export default BulkChangeOpenscapProxyModalScene;

data/webpack/components/HostsIndex/__tests__/ChangeOpenscapProxyAction.test.js

@@ -0,0 +1,172 @@
+import React from 'react';
+import { screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { Menu, MenuContent, MenuList } from '@patternfly/react-core';
+import { rtlHelpers, initMockStore } from 'foremanReact/common/testHelpers';
+import { openBulkModal } from 'foremanReact/common/BulkModalStateHelper';
+import { ForemanActionsBarContext } from 'foremanReact/components/HostDetails/ActionsBar';
+import { STATUS } from 'foremanReact/constants';
+import { APIActions } from 'foremanReact/redux/API';
+import {
+  CHANGE_OPENSCAP_MODAL_ID,
+  OPENSCAP_PROXIES_KEY,
+} from '../../OpenscapRemediationWizard/constants';
+import BulkChangeOpenscapProxyModalScene, {
+  ChangeOpenscapProxyMenuItem,
+} from '../ChangeOpenscapProxyAction';
+
+const { renderWithStore } = rtlHelpers;
+
+jest.spyOn(APIActions, 'get');
+jest.spyOn(APIActions, 'put');
+
+const proxiesResolvedState = {
+  API: {
+    [OPENSCAP_PROXIES_KEY]: {
+      status: STATUS.RESOLVED,
+      response: {
+        results: [
+          { id: 1, name: 'openscap-proxy-1.example.com' },
+          { id: 2, name: 'openscap-proxy-2.example.com' },
+        ],
+      },
+    },
+  },
+};
+
+const actionsBarValue = {
+  selectAllHostsMode: false,
+  selectedCount: 3,
+  fetchBulkParams: jest.fn(() => 'id ^ (1,2,3)'),
+  organizationId: 1,
+  locationId: 2,
+};
+
+const renderMenuItem = (props = {}) =>
+  renderWithStore(
+    // eslint-disable-next-line @theforeman/rules/require-ouiaid
+    <Menu activeItemId={null}>
+      <MenuContent>
+        <MenuList>
+          <ChangeOpenscapProxyMenuItem selectedCount={3} {...props} />
+        </MenuList>
+      </MenuContent>
+    </Menu>
+  );
+
+const renderScene = (contextValue = {}, initialState = proxiesResolvedState) =>
+  renderWithStore(
+    <ForemanActionsBarContext.Provider
+      value={{ ...actionsBarValue, ...contextValue }}
+    >
+      <BulkChangeOpenscapProxyModalScene />
+    </ForemanActionsBarContext.Provider>,
+    initialState
+  );
+
+const renderMenuItemWithScene = (
+  menuProps = {},
+  contextValue = {},
+  initialState = proxiesResolvedState
+) =>
+  renderWithStore(
+    <ForemanActionsBarContext.Provider
+      value={{ ...actionsBarValue, ...contextValue }}
+    >
+      {/* eslint-disable-next-line @theforeman/rules/require-ouiaid */}
+      <Menu activeItemId={null}>
+        <MenuContent>
+          <MenuList>
+            <ChangeOpenscapProxyMenuItem selectedCount={3} {...menuProps} />
+          </MenuList>
+        </MenuContent>
+      </Menu>
+      <BulkChangeOpenscapProxyModalScene />
+    </ForemanActionsBarContext.Provider>,
+    initialState
+  );
+
+describe('ChangeOpenscapProxyMenuItem', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    delete initMockStore.API[OPENSCAP_PROXIES_KEY];
+    openBulkModal(CHANGE_OPENSCAP_MODAL_ID, false);
+    APIActions.get.mockImplementation(payload => ({
+      type: 'TEST_API_GET',
+      payload,
+    }));
+    APIActions.put.mockImplementation(payload => ({
+      type: 'TEST_API_PUT',
+      payload,
+    }));
+  });
+
+  it('renders the OpenSCAP Proxy menu item', () => {
+    renderMenuItem();
+    expect(screen.getByText('OpenSCAP Proxy')).toBeInTheDocument();
+  });
+
+  it('is disabled when no hosts are selected', () => {
+    renderMenuItem({ selectedCount: 0 });
+    expect(
+      screen.getByRole('menuitem', { name: 'OpenSCAP Proxy' })
+    ).toBeDisabled();
+  });
+
+  it('opens the bulk modal when clicked', () => {
+    renderMenuItemWithScene({ selectedCount: 2 });
+
+    expect(screen.queryByText('Assign OpenSCAP Proxy')).not.toBeInTheDocument();
+
+    fireEvent.click(screen.getByText('OpenSCAP Proxy'));
+
+    expect(screen.getByText('Assign OpenSCAP Proxy')).toBeInTheDocument();
+  });
+});
+
+describe('BulkChangeOpenscapProxyModalScene', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    delete initMockStore.API[OPENSCAP_PROXIES_KEY];
+    openBulkModal(CHANGE_OPENSCAP_MODAL_ID, false);
+    APIActions.get.mockImplementation(payload => ({
+      type: 'TEST_API_GET',
+      payload,
+    }));
+    APIActions.put.mockImplementation(payload => ({
+      type: 'TEST_API_PUT',
+      payload,
+    }));
+  });
+
+  it('does not render the modal when closed', () => {
+    renderScene();
+    expect(screen.queryByText('Assign OpenSCAP Proxy')).not.toBeInTheDocument();
+  });
+
+  it('passes actions-bar context props when the modal is open', () => {
+    openBulkModal(CHANGE_OPENSCAP_MODAL_ID, true);
+    renderScene({
+      selectAllHostsMode: true,
+      selectedCount: 5,
+      organizationId: 10,
+      locationId: 20,
+    });
+
+    expect(screen.getByText('Assign OpenSCAP Proxy')).toBeInTheDocument();
+    expect(screen.getByText('ALL selected hosts.')).toBeInTheDocument();
+    expect(
+      screen.getByRole('button', { name: 'Select OpenSCAP Proxy' })
+    ).toBeInTheDocument();
+  });
+
+  it('closes the modal via Cancel', () => {
+    openBulkModal(CHANGE_OPENSCAP_MODAL_ID, true);
+    renderScene();
+
+    expect(screen.getByText('Assign OpenSCAP Proxy')).toBeInTheDocument();
+
+    fireEvent.click(screen.getByRole('button', { name: 'Cancel' }));
+    expect(screen.queryByText('Assign OpenSCAP Proxy')).not.toBeInTheDocument();
+  });
+});

data/webpack/components/OpenscapRemediationWizard/constants.js

@@ -1,7 +1,5 @@
 import { translate as __ } from 'foremanReact/common/I18n';
 
-export const OPENSCAP_REMEDIATION_MODAL_ID = 'openscapRemediationModal';
-export const HOSTS_PATH = '/hosts';
 export const FAIL_RULE_SEARCH = 'fails_xccdf_rule';
 
 export const HOSTS_API_PATH = '/api/hosts';
@@ -24,3 +22,8 @@ export const WIZARD_TITLES = {
   reviewRemediation: __('Review remediation'),
   finish: __('Done'),
 };
+
+export const BULK_CHANGE_OPENSCAP_PROXY_KEY = 'BULK_CHANGE_OPENSCAP_PROXY';
+export const OPENSCAP_PROXIES_KEY = 'OPENSCAP_PROXIES_KEY';
+
+export const CHANGE_OPENSCAP_MODAL_ID = 'BULK_CHANGE_OPENSCAP_PROXY_MODAL';

data/webpack/components/RuleSeverity/RuleSeverity.test.js

@@ -1,13 +1,40 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
 
 import RuleSeverity from './index';
 
-const levels = ['Low', 'Medium', 'High', 'Critical', 'foo'];
+jest.mock('./i_severity-critical.svg', () => 'critical.svg');
+jest.mock('./i_severity-high.svg', () => 'high.svg');
+jest.mock('./i_severity-med.svg', () => 'med.svg');
+jest.mock('./i_severity-low.svg', () => 'low.svg');
+jest.mock('./i_unknown.svg', () => 'unknown.svg');
 
-const fixtures = levels.reduce((memo, level) => {
-  memo[`should render for ${level} severity`] = { severity: level };
-  return memo;
-}, {});
+describe('RuleSeverity', () => {
+  it.each([
+    ['low', 'Low Severity', 'low.svg'],
+    ['medium', 'Medium Severity', 'med.svg'],
+    ['high', 'High Severity', 'high.svg'],
+    ['critical', 'Critical Severity', 'critical.svg'],
+    ['unknown', 'Unknown Severity', 'unknown.svg'],
+  ])('renders the %s severity icon', (severity, altText, iconSrc) => {
+    render(<RuleSeverity severity={severity} />);
 
-describe('RuleSeverity', () =>
-  testComponentSnapshotsWithFixtures(RuleSeverity, fixtures));
+    const icon = screen.getByRole('img', { name: altText });
+
+    expect(icon).toBeInTheDocument();
+    expect(icon).toHaveAttribute('src', iconSrc);
+  });
+
+  it.each(['foo', 'Low', 'Medium', 'High', 'Critical'])(
+    'renders the unknown severity icon for unrecognized severity %s',
+    severity => {
+      render(<RuleSeverity severity={severity} />);
+
+      const icon = screen.getByRole('img', { name: 'Unknown Severity' });
+
+      expect(icon).toBeInTheDocument();
+      expect(icon).toHaveAttribute('src', 'unknown.svg');
+    }
+  );
+});

data/webpack/components/RuleSeverity/index.js

@@ -11,14 +11,14 @@ import './RuleSeverity.scss';
 
 const RuleSeverity = props => {
   const propsMapping = {
-    low: { alt: 'Low Serverity', src: SeverityLow },
-    medium: { alt: 'Medium Serverity', src: SeverityMedium },
-    high: { alt: 'High Serverity', src: SeverityHigh },
+    low: { alt: 'Low Severity', src: SeverityLow },
+    medium: { alt: 'Medium Severity', src: SeverityMedium },
+    high: { alt: 'High Severity', src: SeverityHigh },
     critical: {
-      alt: 'Critical Serverity',
+      alt: 'Critical Severity',
       src: SeverityCritical,
     },
-    unknown: { alt: 'Unknown Serverity', src: SeverityUnknown },
+    unknown: { alt: 'Unknown Severity', src: SeverityUnknown },
   };
 
   const imgProps = propsMapping[props.severity] || propsMapping.unknown;

data/webpack/global_index.js

@@ -1,6 +1,12 @@
 import React from 'react';
 import { addGlobalFill } from 'foremanReact/components/common/Fill/GlobalFill';
 import HostKebabItems from './components/HostExtentions/HostKebabItems';
+import BulkChangeOpenscapProxyModalScene, {
+  ChangeOpenscapProxyMenuItem,
+} from './components/HostsIndex/ChangeOpenscapProxyAction';
+
+const HOST_ASSOCIATIONS_WEIGHT = 1212;
+const BULK_MODAL_WEIGHT = 100;
 
 const OPENSCAP_KEBAB_WEIGHT = 400;
 
@@ -10,3 +16,17 @@ addGlobalFill(
   <HostKebabItems key="openscap-host-kebab" />,
   OPENSCAP_KEBAB_WEIGHT
 );
+
+addGlobalFill(
+  '_host-associations',
+  'openscap-change-proxy-menu-item',
+  <ChangeOpenscapProxyMenuItem key="openscap-change-proxy-menu-item" />,
+  HOST_ASSOCIATIONS_WEIGHT
+);
+
+addGlobalFill(
+  '_all-hosts-modals',
+  'BulkChangeOpenscapProxyModal',
+  <BulkChangeOpenscapProxyModalScene key="bulk-change-openscap-proxy-modal" />,
+  BULK_MODAL_WEIGHT
+);

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foreman_openscap
 version: !ruby/object:Gem::Version
-  version: 13.0.1
+  version: 13.1.0
 platform: ruby
 authors:
 - slukasik@redhat.com
@@ -45,6 +45,7 @@ files:
 - app/assets/stylesheets/foreman_openscap/reports.css
 - app/assets/stylesheets/foreman_openscap/scap_breakdown_chart.css
 - app/controllers/api/v2/compliance/arf_reports_controller.rb
+- app/controllers/api/v2/compliance/hosts_bulk_actions_controller.rb
 - app/controllers/api/v2/compliance/policies_controller.rb
 - app/controllers/api/v2/compliance/scap_content_profiles_controller.rb
 - app/controllers/api/v2/compliance/scap_contents_controller.rb
@@ -333,6 +334,7 @@ files:
 - test/files/tailoring_files/ssg-firefox-ds-tailoring-2.xml
 - test/files/tailoring_files/ssg-firefox-ds-tailoring.xml
 - test/functional/api/v2/compliance/arf_reports_controller_test.rb
+- test/functional/api/v2/compliance/hosts_bulk_actions_controller_test.rb
 - test/functional/api/v2/compliance/policies_controller_test.rb
 - test/functional/api/v2/compliance/scap_content_profiles_controller_test.rb
 - test/functional/api/v2/compliance/scap_contents_controller_test.rb
@@ -364,6 +366,10 @@ files:
 - test/unit/tailoring_file_test.rb
 - webpack/components/EmptyState.js
 - webpack/components/HostExtentions/HostKebabItems.js
+- webpack/components/HostsIndex/BulkActions/changeOpenscapProxy/BulkChangeOpenscapProxyModal.js
+- webpack/components/HostsIndex/BulkActions/changeOpenscapProxy/__tests__/BulkChangeOpenscapProxyModal.test.js
+- webpack/components/HostsIndex/ChangeOpenscapProxyAction.js
+- webpack/components/HostsIndex/__tests__/ChangeOpenscapProxyAction.test.js
 - webpack/components/IndexLayout.scss
 - webpack/components/LineChart/LineChart.fixtures.js
 - webpack/components/LineChart/LineChart.scss
@@ -386,7 +392,6 @@ files:
 - webpack/components/OpenscapRemediationWizard/steps/index.js
 - webpack/components/RuleSeverity/RuleSeverity.scss
 - webpack/components/RuleSeverity/RuleSeverity.test.js
-- webpack/components/RuleSeverity/__snapshots__/RuleSeverity.test.js.snap
 - webpack/components/RuleSeverity/i_severity-critical.svg
 - webpack/components/RuleSeverity/i_severity-high.svg
 - webpack/components/RuleSeverity/i_severity-low.svg
@@ -437,6 +442,7 @@ test_files:
 - test/files/tailoring_files/ssg-firefox-ds-tailoring-2.xml
 - test/files/tailoring_files/ssg-firefox-ds-tailoring.xml
 - test/functional/api/v2/compliance/arf_reports_controller_test.rb
+- test/functional/api/v2/compliance/hosts_bulk_actions_controller_test.rb
 - test/functional/api/v2/compliance/policies_controller_test.rb
 - test/functional/api/v2/compliance/scap_content_profiles_controller_test.rb
 - test/functional/api/v2/compliance/scap_contents_controller_test.rb

data/webpack/components/RuleSeverity/__snapshots__/RuleSeverity.test.js.snap

@@ -1,41 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`RuleSeverity should render for Critical severity 1`] = `
-<img
-  alt="Unknown Serverity"
-  className="severity-img"
-  src={[Function]}
-/>
-`;
-
-exports[`RuleSeverity should render for High severity 1`] = `
-<img
-  alt="Unknown Serverity"
-  className="severity-img"
-  src={[Function]}
-/>
-`;
-
-exports[`RuleSeverity should render for Low severity 1`] = `
-<img
-  alt="Unknown Serverity"
-  className="severity-img"
-  src={[Function]}
-/>
-`;
-
-exports[`RuleSeverity should render for Medium severity 1`] = `
-<img
-  alt="Unknown Serverity"
-  className="severity-img"
-  src={[Function]}
-/>
-`;
-
-exports[`RuleSeverity should render for foo severity 1`] = `
-<img
-  alt="Unknown Serverity"
-  className="severity-img"
-  src={[Function]}
-/>
-`;