Merge branch '214990-license-check-mr-ui' into 'master'

Add MR widget support for license check

See merge request gitlab-org/gitlab!34034

ee/app/assets/javascripts/vue_merge_request_widget/components/states/mr_widget_policy_violation.vue

+<script>
+import { GlButton } from '@gitlab/ui';
+import StatusIcon from '~/vue_merge_request_widget/components/mr_widget_status_icon.vue';
+
+export default {
+  name: 'MRWidgetPolicyViolation',
+  components: {
+    GlButton,
+    StatusIcon,
+  },
+};
+</script>
+<template>
+  <div class="mr-widget-body media">
+    <div class="space-children gl-display-flex">
+      <status-icon status="warning" />
+      <gl-button category="primary" variant="success" disabled size="small">
+        {{ s__('mrWidget|Merge') }}
+      </gl-button>
+    </div>
+    <div class="media-body">
+      <strong class="gl-font-weight-bold gl-text-gray-800 gl-pl-2">
+        {{ s__('mrWidget|You can only merge once the denied license is removed') }}
+      </strong>
+    </div>
+  </div>
+</template>

ee/app/assets/javascripts/vue_merge_request_widget/mr_widget_options.vue

@@ -12,6 +12,7 @@ import { n__, s__, __, sprintf } from '~/locale';
 import CEWidgetOptions from '~/vue_merge_request_widget/mr_widget_options.vue';
 import MrWidgetApprovals from './components/approvals/approvals.vue';
 import MrWidgetGeoSecondaryNode from './components/states/mr_widget_secondary_geo_node.vue';
+import MrWidgetPolicyViolation from './components/states/mr_widget_policy_violation.vue';
 import MergeTrainHelperText from './components/merge_train_helper_text.vue';
 import { MTWPS_MERGE_STRATEGY } from '~/vue_merge_request_widget/constants';
 
@@ -21,6 +22,7 @@ export default {
     MrWidgetLicenses,
     MrWidgetApprovals,
     MrWidgetGeoSecondaryNode,
+    MrWidgetPolicyViolation,
     BlockingMergeRequestsReport,
     GroupedSecurityReportsApp,
     GroupedMetricsReportsApp,
@@ -442,6 +444,7 @@ export default {
       <mr-widget-licenses
         v-if="shouldRenderLicenseReport"
         :api-url="mr.licenseScanning.managed_licenses_path"
+        :approvals-api-path="mr.apiApprovalsPath"
         :licenses-api-path="licensesApiPath"
         :pipeline-path="mr.pipeline.path"
         :can-manage-licenses="mr.licenseScanning.can_manage_licenses"

ee/app/assets/javascripts/vue_merge_request_widget/stores/get_state_key.js

 import CEGetStateKey from '~/vue_merge_request_widget/stores/get_state_key';
+import { stateKey } from './state_maps';
 
 export default function(data) {
   if (this.isGeoSecondaryNode) {
     return 'geoSecondaryNode';
   }
 
+  if (data.policy_violation) {
+    return stateKey.policyViolation;
+  }
+
   return CEGetStateKey.call(this, data);
 }

ee/app/assets/javascripts/vue_merge_request_widget/stores/state_maps.js

 import stateMaps from '~/vue_merge_request_widget/stores/state_maps';
 
 stateMaps.stateToComponentMap.geoSecondaryNode = 'mr-widget-geo-secondary-node';
+stateMaps.stateToComponentMap.policyViolation = 'mr-widget-policy-violation';
+
+export const stateKey = {
+  policyViolation: 'policyViolation',
+};
 
 export default {
   stateToComponentMap: stateMaps.stateToComponentMap,

ee/app/assets/javascripts/vue_shared/license_compliance/mr_widget_license_report.vue

@@ -46,6 +46,11 @@ export default {
       required: false,
       default: '',
     },
+    approvalsApiPath: {
+      type: String,
+      required: false,
+      default: '',
+    },
     canManageLicenses: {
       type: Boolean,
       required: true,
@@ -94,18 +99,24 @@ export default {
     },
   },
   mounted() {
-    const { apiUrl, canManageLicenses, licensesApiPath } = this;
+    const { apiUrl, canManageLicenses, licensesApiPath, approvalsApiPath } = this;
 
     this.setAPISettings({
       apiUrlManageLicenses: apiUrl,
       canManageLicenses,
       licensesApiPath,
+      approvalsApiPath,
     });
 
     this.fetchParsedLicenseReport();
+    this.fetchLicenseCheckApprovalRule();
   },
   methods: {
-    ...mapActions(LICENSE_MANAGEMENT, ['setAPISettings', 'fetchParsedLicenseReport']),
+    ...mapActions(LICENSE_MANAGEMENT, [
+      'setAPISettings',
+      'fetchParsedLicenseReport',
+      'fetchLicenseCheckApprovalRule',
+    ]),
   },
 };
 </script>

ee/app/assets/javascripts/vue_shared/license_compliance/store/actions.js

@@ -2,6 +2,7 @@ import axios from '~/lib/utils/axios_utils';
 import pollUntilComplete from '~/lib/utils/poll_until_complete';
 import * as types from './mutation_types';
 import { LICENSE_APPROVAL_STATUS } from '../constants';
+import { LICENSE_CHECK_NAME } from 'ee/approvals/constants';
 import { convertToOldReportFormat } from './utils';
 
 export const setAPISettings = ({ commit }, data) => {
@@ -111,6 +112,47 @@ export const receiveSetLicenseApprovalError = ({ commit }, error) => {
   commit(types.RECEIVE_SET_LICENSE_APPROVAL_ERROR, error);
 };
 
+export const fetchLicenseCheckApprovalRule = ({ dispatch, state }) => {
+  dispatch('requestLicenseCheckApprovalRule');
+
+  /* 
+    If we call this action from the "License" tab in the pipeline view,
+    then we don't fetch the approvals since we aren't in the Merge request context.
+    Pipelines cannot have approval rules.
+  */
+  if (!state.approvalsApiPath) {
+    return dispatch(
+      'receiveLicenseCheckApprovalRuleError',
+      new Error('approvalsApiPath not provided'),
+    );
+  }
+
+  return axios
+    .get(state.approvalsApiPath)
+    .then(({ data }) => {
+      const hasLicenseCheckApprovalRule = data.approval_rules_left.some(rule => {
+        return rule.name === LICENSE_CHECK_NAME;
+      });
+
+      dispatch('receiveLicenseCheckApprovalRuleSuccess', { hasLicenseCheckApprovalRule });
+    })
+    .catch(error => {
+      dispatch('receiveLicenseCheckApprovalRuleError', error);
+    });
+};
+
+export const requestLicenseCheckApprovalRule = ({ commit }) => {
+  commit(types.REQUEST_LICENSE_CHECK_APPROVAL_RULE);
+};
+
+export const receiveLicenseCheckApprovalRuleSuccess = ({ commit }, rule) => {
+  commit(types.RECEIVE_LICENSE_CHECK_APPROVAL_RULE_SUCCESS, rule);
+};
+
+export const receiveLicenseCheckApprovalRuleError = ({ commit }, error) => {
+  commit(types.RECEIVE_LICENSE_CHECK_APPROVAL_RULE_ERROR, error);
+};
+
 export const setIsAdmin = ({ commit }, payload) => {
   commit(types.SET_IS_ADMIN, payload);
 };

ee/app/assets/javascripts/vue_shared/license_compliance/store/getters.js

@@ -2,7 +2,10 @@ import { n__, s__, sprintf } from '~/locale';
 import { addLicensesMatchingReportGroupStatus, reportGroupHasAtLeastOneLicense } from './utils';
 import { LICENSE_APPROVAL_STATUS, REPORT_GROUPS } from '../constants';
 
-export const isLoading = state => state.isLoadingManagedLicenses || state.isLoadingLicenseReport;
+export const isLoading = state =>
+  state.isLoadingManagedLicenses ||
+  state.isLoadingLicenseReport ||
+  state.isLoadingLicenseCheckApprovalRule;
 
 export const isLicenseBeingUpdated = state => (id = null) => state.pendingLicenses.includes(id);
 
@@ -17,10 +20,19 @@ export const licenseReportGroups = state =>
     reportGroupHasAtLeastOneLicense,
   );
 
-export const licenseSummaryText = (state, getters) => {
-  const hasReportItems = getters.licenseReport && getters.licenseReport.length;
-  const baseReportHasLicenses = state.existingLicenses.length;
+export const hasReportItems = (_, getters) => {
+  return Boolean(getters.licenseReportLength);
+};
+
+export const baseReportHasLicenses = state => {
+  return Boolean(state.existingLicenses.length);
+};
 
+export const licenseReportLength = (_, getters) => {
+  return getters.licenseReport.length;
+};
+
+export const licenseSummaryText = (state, getters) => {
   if (getters.isLoading) {
     return sprintf(s__('ciReport|Loading %{reportName} report'), {
       reportName: s__('License Compliance'),
@@ -33,43 +45,75 @@ export const licenseSummaryText = (state, getters) => {
     });
   }
 
-  if (hasReportItems) {
-    const licenseReportLength = getters.licenseReport.length;
-
-    if (!baseReportHasLicenses) {
-      return getters.reportContainsBlacklistedLicense
-        ? n__(
-            'LicenseCompliance|License Compliance detected %d license and policy violation for the source branch only; approval required',
-            'LicenseCompliance|License Compliance detected %d licenses and policy violations for the source branch only; approval required',
-            licenseReportLength,
-          )
-        : n__(
-            'LicenseCompliance|License Compliance detected %d license for the source branch only',
-            'LicenseCompliance|License Compliance detected %d licenses for the source branch only',
-            licenseReportLength,
-          );
-    }
+  if (getters.hasReportItems) {
+    return state.hasLicenseCheckApprovalRule
+      ? getters.summaryTextWithLicenseCheck
+      : getters.summaryTextWithoutLicenseCheck;
+  }
 
+  if (!getters.baseReportHasLicenses) {
+    return s__(
+      'LicenseCompliance|License Compliance detected no licenses for the source branch only',
+    );
+  }
+
+  return s__('LicenseCompliance|License Compliance detected no new licenses');
+};
+
+export const summaryTextWithLicenseCheck = (_, getters) => {
+  if (!getters.baseReportHasLicenses) {
     return getters.reportContainsBlacklistedLicense
       ? n__(
-          'LicenseCompliance|License Compliance detected %d new license and policy violation; approval required',
-          'LicenseCompliance|License Compliance detected %d new licenses and policy violations; approval required',
-          licenseReportLength,
+          'LicenseCompliance|License Compliance detected %d license and policy violation for the source branch only; approval required',
+          'LicenseCompliance|License Compliance detected %d licenses and policy violations for the source branch only; approval required',
+          getters.licenseReportLength,
         )
       : n__(
-          'LicenseCompliance|License Compliance detected %d new license',
-          'LicenseCompliance|License Compliance detected %d new licenses',
-          licenseReportLength,
+          'LicenseCompliance|License Compliance detected %d license for the source branch only',
+          'LicenseCompliance|License Compliance detected %d licenses for the source branch only',
+          getters.licenseReportLength,
         );
   }
 
-  if (!baseReportHasLicenses) {
-    return s__(
-      'LicenseCompliance|License Compliance detected no licenses for the source branch only',
-    );
+  return getters.reportContainsBlacklistedLicense
+    ? n__(
+        'LicenseCompliance|License Compliance detected %d new license and policy violation; approval required',
+        'LicenseCompliance|License Compliance detected %d new licenses and policy violations; approval required',
+        getters.licenseReportLength,
+      )
+    : n__(
+        'LicenseCompliance|License Compliance detected %d new license',
+        'LicenseCompliance|License Compliance detected %d new licenses',
+        getters.licenseReportLength,
+      );
+};
+
+export const summaryTextWithoutLicenseCheck = (_, getters) => {
+  if (!getters.baseReportHasLicenses) {
+    return getters.reportContainsBlacklistedLicense
+      ? n__(
+          'LicenseCompliance|License Compliance detected %d license and policy violation for the source branch only',
+          'LicenseCompliance|License Compliance detected %d licenses and policy violations for the source branch only',
+          getters.licenseReportLength,
+        )
+      : n__(
+          'LicenseCompliance|License Compliance detected %d license for the source branch only',
+          'LicenseCompliance|License Compliance detected %d licenses for the source branch only',
+          getters.licenseReportLength,
+        );
   }
 
-  return s__('LicenseCompliance|License Compliance detected no new licenses');
+  return getters.reportContainsBlacklistedLicense
+    ? n__(
+        'LicenseCompliance|License Compliance detected %d new license and policy violation',
+        'LicenseCompliance|License Compliance detected %d new licenses and policy violations',
+        getters.licenseReportLength,
+      )
+    : n__(
+        'LicenseCompliance|License Compliance detected %d new license',
+        'LicenseCompliance|License Compliance detected %d new licenses',
+        getters.licenseReportLength,
+      );
 };
 
 export const reportContainsBlacklistedLicense = (_, getters) =>

ee/app/assets/javascripts/vue_shared/license_compliance/store/mutation_types.js

@@ -16,6 +16,11 @@ export const SET_LICENSE_IN_MODAL = 'SET_LICENSE_IN_MODAL';
 export const SET_IS_ADMIN = 'SET_IS_ADMIN';
 export const ADD_PENDING_LICENSE = 'ADD_PENDING_LICENSE';
 export const REMOVE_PENDING_LICENSE = 'REMOVE_PENDING_LICENSE';
+export const REQUEST_LICENSE_CHECK_APPROVAL_RULE = 'REQUEST_LICENSE_CHECK_APPROVAL_RULE';
+export const RECEIVE_LICENSE_CHECK_APPROVAL_RULE_SUCCESS =
+  'RECEIVE_LICENSE_CHECK_APPROVAL_RULE_SUCCESS';
+export const RECEIVE_LICENSE_CHECK_APPROVAL_RULE_ERROR =
+  'RECEIVE_LICENSE_CHECK_APPROVAL_RULE_ERROR';
 
 // prevent babel-plugin-rewire from generating an invalid default during karma tests
 export default () => {};

ee/app/assets/javascripts/vue_shared/license_compliance/store/mutations.js

@@ -96,6 +96,22 @@ export default {
       currentLicenseInModal: null,
     });
   },
+  [types.REQUEST_LICENSE_CHECK_APPROVAL_RULE](state) {
+    Object.assign(state, {
+      isLoadingLicenseCheckApprovalRule: true,
+    });
+  },
+  [types.RECEIVE_LICENSE_CHECK_APPROVAL_RULE_SUCCESS](state, { hasLicenseCheckApprovalRule }) {
+    Object.assign(state, {
+      isLoadingLicenseCheckApprovalRule: false,
+      hasLicenseCheckApprovalRule,
+    });
+  },
+  [types.RECEIVE_LICENSE_CHECK_APPROVAL_RULE_ERROR](state) {
+    Object.assign(state, {
+      isLoadingLicenseCheckApprovalRule: false,
+    });
+  },
   [types.ADD_PENDING_LICENSE](state, id) {
     state.pendingLicenses.push(id);
   },

ee/app/assets/javascripts/vue_shared/license_compliance/store/state.js

 export default () => ({
   apiUrlManageLicenses: null,
+  approvalsApiPath: null,
   licensesApiPath: null,
   canManageLicenses: false,
   currentLicenseInModal: null,
@@ -14,4 +15,6 @@ export default () => ({
   managedLicenses: [],
   newLicenses: [],
   existingLicenses: [],
+  hasLicenseCheckApprovalRule: false,
+  isLoadingLicenseCheckApprovalRule: false,
 });

ee/spec/frontend/vue_mr_widget/components/states/mr_widget_policy_violation_spec.js

+import { shallowMount } from '@vue/test-utils';
+import { GlButton } from '@gitlab/ui';
+import MrWidgetPolicyViolation from 'ee/vue_merge_request_widget/components/states/mr_widget_policy_violation.vue';
+
+describe('EE MrWidgetPolicyViolation', () => {
+  let wrapper;
+
+  const findButton = () => wrapper.find(GlButton);
+
+  const createComponent = () => {
+    wrapper = shallowMount(MrWidgetPolicyViolation, {});
+  };
+
+  afterEach(() => {
+    wrapper.destroy();
+    wrapper = null;
+  });
+
+  beforeEach(() => {
+    createComponent();
+  });
+
+  it('shows the disabled merge button', () => {
+    expect(wrapper.text()).toContain('Merge');
+    expect(findButton().props().disabled).toBe(true);
+  });
+
+  it('shows the disabled reason', () => {
+    expect(wrapper.text()).toContain('You can only merge once the denied license is removed');
+  });
+});

ee/spec/frontend/vue_shared/license_compliance/mr_widget_license_report_spec.js

@@ -48,6 +48,7 @@ describe('License Report MR Widget', () => {
     loadingText: 'LOADING',
     errorText: 'ERROR',
     licensesApiPath: `${TEST_HOST}/parsed_license_report.json`,
+    approvalsApiPath: `${TEST_HOST}/path/to/approvals`,
     canManageLicenses: true,
     licenseManagementSettingsPath: `${TEST_HOST}/lm_settings`,
     fullReportPath: `${TEST_HOST}/path/to/the/full/report`,
@@ -59,6 +60,7 @@ describe('License Report MR Widget', () => {
     setAPISettings: () => {},
     fetchManagedLicenses: () => {},
     fetchParsedLicenseReport: () => {},
+    fetchLicenseCheckApprovalRule: () => {},
   };
 
   const mountComponent = ({
@@ -339,8 +341,9 @@ describe('License Report MR Widget', () => {
 
   it('should init store after mount', () => {
     const actions = {
-      setAPISettings: jest.fn(() => {}),
-      fetchParsedLicenseReport: jest.fn(() => {}),
+      setAPISettings: jest.fn(),
+      fetchParsedLicenseReport: jest.fn(),
+      fetchLicenseCheckApprovalRule: jest.fn(),
     };
     mountComponent({ actions });
 
@@ -349,6 +352,7 @@ describe('License Report MR Widget', () => {
       {
         apiUrlManageLicenses: apiUrl,
         licensesApiPath: defaultProps.licensesApiPath,
+        approvalsApiPath: defaultProps.approvalsApiPath,
         canManageLicenses: true,
       },
       undefined,
@@ -359,6 +363,12 @@ describe('License Report MR Widget', () => {
       undefined,
       undefined,
     );
+
+    expect(actions.fetchLicenseCheckApprovalRule).toHaveBeenCalledWith(
+      expect.any(Object),
+      undefined,
+      undefined,
+    );
   });
 
   describe('approval status', () => {

ee/spec/frontend/vue_shared/license_compliance/store/actions_spec.js

@@ -3,6 +3,7 @@ import * as actions from 'ee/vue_shared/license_compliance/store/actions';
 import * as mutationTypes from 'ee/vue_shared/license_compliance/store/mutation_types';
 import createState from 'ee/vue_shared/license_compliance/store/state';
 import { LICENSE_APPROVAL_STATUS } from 'ee/vue_shared/license_compliance/constants';
+import { LICENSE_CHECK_NAME } from 'ee/approvals/constants';
 import { TEST_HOST } from 'spec/test_constants';
 import testAction from 'helpers/vuex_action_helper';
 import { approvedLicense, blacklistedLicense } from '../mock_data';
@@ -10,6 +11,7 @@ import axios from '~/lib/utils/axios_utils';
 
 describe('License store actions', () => {
   const apiUrlManageLicenses = `${TEST_HOST}/licenses/management`;
+  const approvalsApiPath = `${TEST_HOST}/approvalsApiPath`;
   const licensesApiPath = `${TEST_HOST}/licensesApiPath`;
 
   let axiosMock;
@@ -26,6 +28,7 @@ describe('License store actions', () => {
     state = {
       ...createState(),
       apiUrlManageLicenses,
+      approvalsApiPath,
       currentLicenseInModal: approvedLicense,
     };
     licenseId = approvedLicense.id;
@@ -480,6 +483,139 @@ describe('License store actions', () => {
     });
   });
 
+  describe('fetchLicenseCheckApprovalRule ', () => {
+    it('dispatches request/receive with detected approval rule', done => {
+      const APPROVAL_RULE_RESPONSE = {
+        approval_rules_left: [{ name: LICENSE_CHECK_NAME }],
+      };
+
+      axiosMock.onGet(approvalsApiPath).replyOnce(200, APPROVAL_RULE_RESPONSE);
+
+      testAction(
+        actions.fetchLicenseCheckApprovalRule,
+        null,
+        state,
+        [],
+        [
+          { type: 'requestLicenseCheckApprovalRule' },
+          {
+            type: 'receiveLicenseCheckApprovalRuleSuccess',
+            payload: { hasLicenseCheckApprovalRule: true },
+          },
+        ],
+        done,
+      );
+    });
+
+    it('dispatches request/receive without detected approval rule', done => {
+      const APPROVAL_RULE_RESPONSE = {
+        approval_rules_left: [{ name: 'Another Approval Rule' }],
+      };
+
+      axiosMock.onGet(approvalsApiPath).replyOnce(200, APPROVAL_RULE_RESPONSE);
+
+      testAction(
+        actions.fetchLicenseCheckApprovalRule,
+        null,
+        state,
+        [],
+        [
+          { type: 'requestLicenseCheckApprovalRule' },
+          {
+            type: 'receiveLicenseCheckApprovalRuleSuccess',
+            payload: { hasLicenseCheckApprovalRule: false },
+          },
+        ],
+        done,
+      );
+    });
+
+    it('dispatches request/receive error when no approvalsAPiPath is provided', done => {
+      const error = new Error('approvalsApiPath not provided');
+      axiosMock.onGet(approvalsApiPath).replyOnce(500);
+
+      testAction(
+        actions.fetchLicenseCheckApprovalRule,
+        null,
+        { ...state, approvalsApiPath: '' },
+        [],
+        [
+          { type: 'requestLicenseCheckApprovalRule' },
+          { type: 'receiveLicenseCheckApprovalRuleError', payload: error },
+        ],
+        done,
+      );
+    });
+
+    it('dispatches request/receive on error', done => {
+      const error = new Error('Request failed with status code 500');
+      axiosMock.onGet(approvalsApiPath).replyOnce(500);
+
+      testAction(
+        actions.fetchLicenseCheckApprovalRule,
+        null,
+        state,
+        [],
+        [
+          { type: 'requestLicenseCheckApprovalRule' },
+          { type: 'receiveLicenseCheckApprovalRuleError', payload: error },
+        ],
+        done,
+      );
+    });
+  });
+
+  describe('requestLicenseCheckApprovalRule', () => {
+    it('commits REQUEST_LICENSE_CHECK_APPROVAL_RULE', done => {
+      testAction(
+        actions.requestLicenseCheckApprovalRule,
+        null,
+        state,
+        [{ type: mutationTypes.REQUEST_LICENSE_CHECK_APPROVAL_RULE }],
+        [],
+      )
+        .then(done)
+        .catch(done.fail);
+    });
+  });
+
+  describe('receiveLicenseCheckApprovalRuleSuccess', () => {
+    it('commits REQUEST_LICENSE_CHECK_APPROVAL_RULE', done => {
+      const hasLicenseCheckApprovalRule = true;
+
+      testAction(
+        actions.receiveLicenseCheckApprovalRuleSuccess,
+        { hasLicenseCheckApprovalRule },
+        state,
+        [
+          {
+            type: mutationTypes.RECEIVE_LICENSE_CHECK_APPROVAL_RULE_SUCCESS,
+            payload: { hasLicenseCheckApprovalRule },
+          },
+        ],
+        [],
+      )
+        .then(done)
+        .catch(done.fail);
+    });
+  });
+
+  describe('receiveLicenseCheckApprovalRuleError', () => {
+    it('commits RECEIVE_LICENSE_CHECK_APPROVAL_RULE_ERROR', done => {
+      const error = new Error('Error');
+
+      testAction(
+        actions.receiveLicenseCheckApprovalRuleError,
+        error,
+        state,
+        [{ type: mutationTypes.RECEIVE_LICENSE_CHECK_APPROVAL_RULE_ERROR, payload: error }],
+        [],
+      )
+        .then(done)
+        .catch(done.fail);
+    });
+  });
+
   describe('requestParsedLicenseReport', () => {
     it(`should commit ${mutationTypes.REQUEST_PARSED_LICENSE_REPORT}`, done => {
       testAction(

ee/spec/frontend/vue_shared/license_compliance/store/mutations_spec.js

@@ -153,6 +153,54 @@ describe('License store mutations', () => {
     });
   });
 
+  describe('REQUEST_LICENSE_CHECK_APPROVAL_RULE', () => {
+    it('sets isLoadingLicenseCheckApprovalRule to true', () => {
+      store.replaceState({
+        ...store.state,
+        licenseManagement: {
+          isLoadingLicenseCheckApprovalRule: true,
+        },
+      });
+
+      store.commit(`licenseManagement/${types.REQUEST_LICENSE_CHECK_APPROVAL_RULE}`);
+
+      expect(store.state.licenseManagement.isLoadingLicenseCheckApprovalRule).toBe(true);
+    });
+  });
+
+  describe('RECEIVE_LICENSE_CHECK_APPROVAL_RULE_SUCCESS', () => {
+    it('sets isLoadingLicenseCheckApprovalRule to false and hasLicenseCheckApprovalRule to true', () => {
+      store.replaceState({
+        ...store.state,
+        licenseManagement: {
+          isLoadingLicenseCheckApprovalRule: true,
+        },
+      });
+
+      store.commit(`licenseManagement/${types.RECEIVE_LICENSE_CHECK_APPROVAL_RULE_SUCCESS}`, {
+        hasLicenseCheckApprovalRule: true,
+      });
+
+      expect(store.state.licenseManagement.isLoadingLicenseCheckApprovalRule).toBe(false);
+      expect(store.state.licenseManagement.hasLicenseCheckApprovalRule).toBe(true);
+    });
+  });
+
+  describe('RECEIVE_LICENSE_CHECK_APPROVAL_RULE_ERROR', () => {
+    it('sets isLoadingLicenseCheckApprovalRule to false', () => {
+      store.replaceState({
+        ...store.state,
+        licenseManagement: {
+          isLoadingLicenseCheckApprovalRule: true,
+        },
+      });
+
+      store.commit(`licenseManagement/${types.RECEIVE_LICENSE_CHECK_APPROVAL_RULE_ERROR}`);
+
+      expect(store.state.licenseManagement.isLoadingLicenseCheckApprovalRule).toBe(false);
+    });
+  });
+
   describe('RECEIVE_MANAGED_LICENSES_SUCCESS', () => {
     it('sets isLoadingManagedLicenses and loadManagedLicensesError to false and saves managed licenses', () => {
       store.replaceState({

locale/gitlab.pot

@@ -13640,6 +13640,11 @@ msgstr ""
 msgid "LicenseCompliance|License Approvals"
 msgstr ""
 
+msgid "LicenseCompliance|License Compliance detected %d license and policy violation for the source branch only"
+msgid_plural "LicenseCompliance|License Compliance detected %d licenses and policy violations for the source branch only"
+msgstr[0] ""
+msgstr[1] ""
+
 msgid "LicenseCompliance|License Compliance detected %d license and policy violation for the source branch only; approval required"
 msgid_plural "LicenseCompliance|License Compliance detected %d licenses and policy violations for the source branch only; approval required"
 msgstr[0] ""
@@ -13655,6 +13660,11 @@ msgid_plural "LicenseCompliance|License Compliance detected %d new licenses"
 msgstr[0] ""
 msgstr[1] ""
 
+msgid "LicenseCompliance|License Compliance detected %d new license and policy violation"
+msgid_plural "LicenseCompliance|License Compliance detected %d new licenses and policy violations"
+msgstr[0] ""
+msgstr[1] ""
+
 msgid "LicenseCompliance|License Compliance detected %d new license and policy violation; approval required"
 msgid_plural "LicenseCompliance|License Compliance detected %d new licenses and policy violations; approval required"
 msgstr[0] ""
@@ -28173,6 +28183,9 @@ msgstr ""
 msgid "mrWidget|You can merge this merge request manually using the"
 msgstr ""
 
+msgid "mrWidget|You can only merge once the denied license is removed"
+msgstr ""
+
 msgid "mrWidget|Your password"
 msgstr ""