foreman_openscap 13.0.0 → 13.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f58e733e3dd18596f3c7e16c4015103df7729a629577735ccb67ed7912172c3f
-  data.tar.gz: c87d597fcae523beb2f8607bc4a88bb77ee2508ce127b19761f6030d6eefd3e5
+  metadata.gz: 18cf4b07fd89183f5ced6a907f35a88be64e9a19461dfdfc68511d826e42797e
+  data.tar.gz: f581fc51af310ca96c388121914040d7885d2b81d42c14e1982a8efa6501c336
 SHA512:
-  metadata.gz: 5a7eb9acc11cac66fc65081c49bb6bfb4cbe58fbc5accadf5896ba19af130d9237a8825215c6a866d68252dc51f5cdd28516b072494f8c969960b47e63221e1f
-  data.tar.gz: c68a53b00952b47560b977ebb6a661c24a3ab7a064f8ddfc05ba4a1c26e97882796db01556bd57fa705a6637a1df4073ff083716ff7909a9c11d1a333a9ac735
+  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.0".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();
+  });
+});