source.dussan.org Git - sonarqube.git/blob

   1 /*
   2  * SonarQube
   3  * Copyright (C) 2009-2023 SonarSource SA
   4  * mailto:info AT sonarsource DOT com
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 3 of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20 import { shallow } from 'enzyme';
  21 import * as React from 'react';
  22 import { FormattedMessage } from 'react-intl';
  23 import { Alert } from '../../../../../components/ui/Alert';
  24 import { hasMessage } from '../../../../../helpers/l10n';
  25 import { mockComponent } from '../../../../../helpers/mocks/component';
  26 import { mockTask } from '../../../../../helpers/mocks/tasks';
  27 import { mockLocation } from '../../../../../helpers/testMocks';
  28 import { Task, TaskStatuses, TaskTypes } from '../../../../../types/tasks';
  29 import { ComponentNavBgTaskNotif } from '../ComponentNavBgTaskNotif';
  30
  31 jest.mock('../../../../../helpers/l10n', () => ({
  32   ...jest.requireActual('../../../../../helpers/l10n'),
  33   hasMessage: jest.fn().mockReturnValue(true),
  34 }));
  35
  36 const UNKNOWN_TASK_TYPE: TaskTypes = 'UNKOWN' as TaskTypes;
  37
  38 it('renders correctly', () => {
  39   expect(shallowRender()).toMatchSnapshot('default');
  40   expect(
  41     shallowRender({
  42       currentTask: mockTask({
  43         status: TaskStatuses.Failed,
  44         errorType: 'LICENSING',
  45         errorMessage: 'Foo',
  46       }),
  47     })
  48   ).toMatchSnapshot('license issue');
  49   expect(shallowRender({ currentTask: undefined }).type()).toBeNull(); // No task.
  50 });
  51
  52 it.each([
  53   // failed
  54   [
  55     'component_navigation.status.failed',
  56     'error',
  57     mockTask({ status: TaskStatuses.Failed, type: UNKNOWN_TASK_TYPE }),
  58     false,
  59     false,
  60     false,
  61     false,
  62   ],
  63   [
  64     'component_navigation.status.failed_X',
  65     'error',
  66     mockTask({ status: TaskStatuses.Failed }),
  67     false,
  68     false,
  69     false,
  70     false,
  71   ],
  72   [
  73     'component_navigation.status.failed.admin.link',
  74     'error',
  75     mockTask({ status: TaskStatuses.Failed, type: UNKNOWN_TASK_TYPE }),
  76     false,
  77     false,
  78     true,
  79     false,
  80   ],
  81   [
  82     'component_navigation.status.failed_X.admin.link',
  83     'error',
  84     mockTask({ status: TaskStatuses.Failed }),
  85     false,
  86     false,
  87     true,
  88     false,
  89   ],
  90   [
  91     'component_navigation.status.failed.admin.help',
  92     'error',
  93     mockTask({ status: TaskStatuses.Failed, type: UNKNOWN_TASK_TYPE }),
  94     false,
  95     false,
  96     true,
  97     true,
  98   ],
  99   [
 100     'component_navigation.status.failed_X.admin.help',
 101     'error',
 102     mockTask({ status: TaskStatuses.Failed }),
 103     false,
 104     false,
 105     true,
 106     true,
 107   ],
 108   // failed_branch
 109   [
 110     'component_navigation.status.failed_branch',
 111     'error',
 112     mockTask({ status: TaskStatuses.Failed, branch: 'foo', type: UNKNOWN_TASK_TYPE }),
 113     false,
 114     false,
 115     false,
 116     false,
 117   ],
 118   [
 119     'component_navigation.status.failed_branch_X',
 120     'error',
 121     mockTask({ status: TaskStatuses.Failed, branch: 'foo' }),
 122     false,
 123     false,
 124     false,
 125     false,
 126   ],
 127   [
 128     'component_navigation.status.failed_branch.admin.link',
 129     'error',
 130     mockTask({ status: TaskStatuses.Failed, branch: 'foo', type: UNKNOWN_TASK_TYPE }),
 131     false,
 132     false,
 133     true,
 134     false,
 135   ],
 136   [
 137     'component_navigation.status.failed_branch_X.admin.link',
 138     'error',
 139     mockTask({ status: TaskStatuses.Failed, branch: 'foo' }),
 140     false,
 141     false,
 142     true,
 143     false,
 144   ],
 145   [
 146     'component_navigation.status.failed_branch.admin.help',
 147     'error',
 148     mockTask({ status: TaskStatuses.Failed, branch: 'foo', type: UNKNOWN_TASK_TYPE }),
 149     false,
 150     false,
 151     true,
 152     true,
 153   ],
 154   [
 155     'component_navigation.status.failed_branch_X.admin.help',
 156     'error',
 157     mockTask({ status: TaskStatuses.Failed, branch: 'foo' }),
 158     false,
 159     false,
 160     true,
 161     true,
 162   ],
 163   // pending
 164   [
 165     'component_navigation.status.pending',
 166     'info',
 167     mockTask({ type: UNKNOWN_TASK_TYPE }),
 168     true,
 169     false,
 170     false,
 171     false,
 172   ],
 173   ['component_navigation.status.pending_X', 'info', mockTask(), true, false, false, false],
 174   [
 175     'component_navigation.status.pending.admin.link',
 176     'info',
 177     mockTask({ type: UNKNOWN_TASK_TYPE }),
 178     true,
 179     false,
 180     true,
 181     false,
 182   ],
 183   [
 184     'component_navigation.status.pending_X.admin.link',
 185     'info',
 186     mockTask(),
 187     true,
 188     false,
 189     true,
 190     false,
 191   ],
 192   [
 193     'component_navigation.status.pending.admin.help',
 194     'info',
 195     mockTask({ type: UNKNOWN_TASK_TYPE }),
 196     true,
 197     false,
 198     true,
 199     true,
 200   ],
 201   [
 202     'component_navigation.status.pending_X.admin.help',
 203     'info',
 204     mockTask({ status: TaskStatuses.Failed }),
 205     true,
 206     false,
 207     true,
 208     true,
 209   ],
 210   // in_progress
 211   [
 212     'component_navigation.status.in_progress',
 213     'info',
 214     mockTask({ type: UNKNOWN_TASK_TYPE }),
 215     true,
 216     true,
 217     false,
 218     false,
 219   ],
 220   ['component_navigation.status.in_progress_X', 'info', mockTask(), true, true, false, false],
 221   [
 222     'component_navigation.status.in_progress.admin.link',
 223     'info',
 224     mockTask({ type: UNKNOWN_TASK_TYPE }),
 225     true,
 226     true,
 227     true,
 228     false,
 229   ],
 230   [
 231     'component_navigation.status.in_progress_X.admin.link',
 232     'info',
 233     mockTask(),
 234     true,
 235     true,
 236     true,
 237     false,
 238   ],
 239   [
 240     'component_navigation.status.in_progress.admin.help',
 241     'info',
 242     mockTask({ type: UNKNOWN_TASK_TYPE }),
 243     true,
 244     true,
 245     true,
 246     true,
 247   ],
 248   [
 249     'component_navigation.status.in_progress_X.admin.help',
 250     'info',
 251     mockTask({ status: TaskStatuses.Failed }),
 252     true,
 253     true,
 254     true,
 255     true,
 256   ],
 257 ])(
 258   'should render the expected message=%p',
 259   (
 260     expectedMessage: string,
 261     alertVariant: string,
 262     currentTask: Task,
 263     isPending: boolean,
 264     isInProgress: boolean,
 265     showBackgroundTasks: boolean,
 266     onBackgroudTaskPage: boolean
 267   ) => {
 268     if (currentTask.type === UNKNOWN_TASK_TYPE) {
 269       (hasMessage as jest.Mock).mockReturnValueOnce(false);
 270     }
 271
 272     const wrapper = shallowRender({
 273       component: mockComponent({ configuration: { showBackgroundTasks } }),
 274       currentTask,
 275       currentTaskOnSameBranch: !currentTask.branch,
 276       isPending,
 277       isInProgress,
 278       location: mockLocation({
 279         pathname: onBackgroudTaskPage ? '/project/background_tasks' : '/foo/bar',
 280       }),
 281     });
 282     const messageProps = wrapper.find<FormattedMessage>(FormattedMessage).props();
 283
 284     // Translation key.
 285     expect(messageProps.defaultMessage).toBe(expectedMessage);
 286
 287     // Alert variant.
 288     expect(wrapper.find(Alert).props().variant).toBe(alertVariant);
 289
 290     // Formatted message values prop.
 291     // eslint-disable-next-line jest/no-conditional-in-test
 292     if (/_X/.test(expectedMessage)) {
 293       // eslint-disable-next-line jest/no-conditional-expect
 294       expect(messageProps.values?.type).toBe(`background_task.type.${currentTask.type}`);
 295     } else {
 296       // eslint-disable-next-line jest/no-conditional-expect
 297       expect(messageProps.values?.type).toBeUndefined();
 298     }
 299
 300     // eslint-disable-next-line jest/no-conditional-in-test
 301     if (currentTask.branch) {
 302       // eslint-disable-next-line jest/no-conditional-expect
 303       expect(messageProps.values?.branch).toBe(currentTask.branch);
 304     } else {
 305       // eslint-disable-next-line jest/no-conditional-expect
 306       expect(messageProps.values?.branch).toBeUndefined();
 307     }
 308
 309     // eslint-disable-next-line jest/no-conditional-in-test
 310     if (showBackgroundTasks) {
 311       // eslint-disable-next-line jest/no-conditional-in-test
 312       if (onBackgroudTaskPage) {
 313         // eslint-disable-next-line jest/no-conditional-expect
 314         expect(messageProps.values?.url).toBeUndefined();
 315         // eslint-disable-next-line jest/no-conditional-expect
 316         expect(messageProps.values?.stacktrace).toBe('background_tasks.show_stacktrace');
 317       } else {
 318         // eslint-disable-next-line jest/no-conditional-expect
 319         expect(messageProps.values?.url).toBeDefined();
 320         // eslint-disable-next-line jest/no-conditional-expect
 321         expect(messageProps.values?.stacktrace).toBeUndefined();
 322       }
 323     } else {
 324       // eslint-disable-next-line jest/no-conditional-expect
 325       expect(messageProps.values?.url).toBeUndefined();
 326       // eslint-disable-next-line jest/no-conditional-expect
 327       expect(messageProps.values?.stacktrace).toBeUndefined();
 328     }
 329   }
 330 );
 331
 332 function shallowRender(props: Partial<ComponentNavBgTaskNotif['props']> = {}) {
 333   return shallow<ComponentNavBgTaskNotif>(
 334     <ComponentNavBgTaskNotif
 335       component={mockComponent()}
 336       currentTask={mockTask({ status: TaskStatuses.Failed })}
 337       location={mockLocation()}
 338       {...props}
 339     />
 340   );
 341 }