debian-mirror-gitlab/spec/frontend/monitoring/components/dashboard_panel_spec.js

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

698 lines
21 KiB
JavaScript
Raw Normal View History

2021-03-11 19:13:27 +05:30
import { GlDropdownItem } from '@gitlab/ui';
2020-03-13 15:44:24 +05:30
import { shallowMount } from '@vue/test-utils';
import AxiosMockAdapter from 'axios-mock-adapter';
2021-03-11 19:13:27 +05:30
import Vuex from 'vuex';
2022-04-04 11:22:00 +05:30
import { nextTick } from 'vue';
2020-03-13 15:44:24 +05:30
import { setTestTimeout } from 'helpers/timeout';
import axios from '~/lib/utils/axios_utils';
2021-03-11 19:13:27 +05:30
import invalidUrl from '~/lib/utils/invalid_url';
2020-03-13 15:44:24 +05:30
2021-03-11 19:13:27 +05:30
import MonitorAnomalyChart from '~/monitoring/components/charts/anomaly.vue';
import MonitorBarChart from '~/monitoring/components/charts/bar.vue';
import MonitorColumnChart from '~/monitoring/components/charts/column.vue';
import MonitorEmptyChart from '~/monitoring/components/charts/empty_chart.vue';
import MonitorHeatmapChart from '~/monitoring/components/charts/heatmap.vue';
import MonitorSingleStatChart from '~/monitoring/components/charts/single_stat.vue';
import MonitorStackedColumnChart from '~/monitoring/components/charts/stacked_column.vue';
import MonitorTimeSeriesChart from '~/monitoring/components/charts/time_series.vue';
2020-05-24 23:13:21 +05:30
import DashboardPanel from '~/monitoring/components/dashboard_panel.vue';
2021-03-11 19:13:27 +05:30
import { panelTypes } from '~/monitoring/constants';
import { createStore, monitoringDashboard } from '~/monitoring/stores';
import { createStore as createEmbedGroupStore } from '~/monitoring/stores/embed_group';
import { dashboardProps, graphData, graphDataEmpty } from '../fixture_data';
import {
anomalyGraphData,
singleStatGraphData,
heatmapGraphData,
barGraphData,
} from '../graph_data';
2020-04-22 19:07:51 +05:30
import {
mockLogsHref,
mockLogsPath,
mockNamespace,
mockNamespacedData,
mockTimeRange,
} from '../mock_data';
2020-03-13 15:44:24 +05:30
const mocks = {
$toast: {
show: jest.fn(),
},
};
2020-05-24 23:13:21 +05:30
describe('Dashboard Panel', () => {
2020-03-13 15:44:24 +05:30
let axiosMock;
let store;
let state;
let wrapper;
const exampleText = 'example_text';
const findCopyLink = () => wrapper.find({ ref: 'copyChartLink' });
2020-05-24 23:13:21 +05:30
const findTimeChart = () => wrapper.find({ ref: 'timeSeriesChart' });
2020-04-22 19:07:51 +05:30
const findTitle = () => wrapper.find({ ref: 'graphTitle' });
2020-06-23 00:09:42 +05:30
const findCtxMenu = () => wrapper.find({ ref: 'contextualMenu' });
const findMenuItems = () => wrapper.findAll(GlDropdownItem);
2021-03-08 18:12:59 +05:30
const findMenuItemByText = (text) => findMenuItems().filter((i) => i.text() === text);
2020-03-13 15:44:24 +05:30
2020-10-24 23:57:45 +05:30
const createWrapper = (props, { mountFn = shallowMount, ...options } = {}) => {
wrapper = mountFn(DashboardPanel, {
2020-03-13 15:44:24 +05:30
propsData: {
2020-04-22 19:07:51 +05:30
graphData,
2020-07-28 23:09:34 +05:30
settingsPath: dashboardProps.settingsPath,
2020-03-13 15:44:24 +05:30
...props,
},
store,
mocks,
2022-07-16 23:28:13 +05:30
provide: { glFeatures: { monitorLogging: true } },
2020-05-24 23:13:21 +05:30
...options,
2020-03-13 15:44:24 +05:30
});
};
2020-06-23 00:09:42 +05:30
const mockGetterReturnValue = (getter, value) => {
jest.spyOn(monitoringDashboard.getters, getter).mockReturnValue(value);
store = new Vuex.Store({
modules: {
monitoringDashboard,
},
});
};
2020-03-13 15:44:24 +05:30
beforeEach(() => {
setTestTimeout(1000);
store = createStore();
state = store.state.monitoringDashboard;
axiosMock = new AxiosMockAdapter(axios);
2021-01-03 14:25:43 +05:30
jest.spyOn(URL, 'createObjectURL');
2020-03-13 15:44:24 +05:30
});
afterEach(() => {
axiosMock.reset();
});
2020-05-24 23:13:21 +05:30
describe('Renders slots', () => {
it('renders "topLeft" slot', () => {
createWrapper(
{},
{
slots: {
2021-01-29 00:20:46 +05:30
'top-left': `<div class="top-left-content">OK</div>`,
2020-05-24 23:13:21 +05:30
},
},
);
expect(wrapper.find('.top-left-content').exists()).toBe(true);
expect(wrapper.find('.top-left-content').text()).toBe('OK');
});
});
2020-03-13 15:44:24 +05:30
describe('When no graphData is available', () => {
beforeEach(() => {
createWrapper({
2020-04-22 19:07:51 +05:30
graphData: graphDataEmpty,
2020-03-13 15:44:24 +05:30
});
});
afterEach(() => {
wrapper.destroy();
});
2020-05-24 23:13:21 +05:30
it('renders the chart title', () => {
expect(findTitle().text()).toBe(graphDataEmpty.title);
});
2020-04-08 14:13:33 +05:30
2020-05-24 23:13:21 +05:30
it('renders no download csv link', () => {
expect(wrapper.find({ ref: 'downloadCsvLink' }).exists()).toBe(false);
});
2020-04-08 14:13:33 +05:30
2020-05-24 23:13:21 +05:30
it('does not contain graph widgets', () => {
2020-06-23 00:09:42 +05:30
expect(findCtxMenu().exists()).toBe(false);
2020-05-24 23:13:21 +05:30
});
2020-04-08 14:13:33 +05:30
2020-05-24 23:13:21 +05:30
it('The Empty Chart component is rendered and is a Vue instance', () => {
expect(wrapper.find(MonitorEmptyChart).exists()).toBe(true);
});
});
describe('When graphData is null', () => {
beforeEach(() => {
createWrapper({
graphData: null,
2020-03-13 15:44:24 +05:30
});
});
2020-05-24 23:13:21 +05:30
afterEach(() => {
wrapper.destroy();
});
it('renders no chart title', () => {
expect(findTitle().text()).toBe('');
});
it('renders no download csv link', () => {
expect(wrapper.find({ ref: 'downloadCsvLink' }).exists()).toBe(false);
});
it('does not contain graph widgets', () => {
2020-06-23 00:09:42 +05:30
expect(findCtxMenu().exists()).toBe(false);
2020-05-24 23:13:21 +05:30
});
it('The Empty Chart component is rendered and is a Vue instance', () => {
expect(wrapper.find(MonitorEmptyChart).exists()).toBe(true);
});
2020-03-13 15:44:24 +05:30
});
2020-05-24 23:13:21 +05:30
describe('When graphData is available', () => {
2020-03-13 15:44:24 +05:30
beforeEach(() => {
2020-04-22 19:07:51 +05:30
createWrapper();
2020-03-13 15:44:24 +05:30
});
afterEach(() => {
wrapper.destroy();
});
2020-04-08 14:13:33 +05:30
it('renders the chart title', () => {
2020-04-22 19:07:51 +05:30
expect(findTitle().text()).toBe(graphData.title);
2020-04-08 14:13:33 +05:30
});
it('contains graph widgets', () => {
2020-06-23 00:09:42 +05:30
expect(findCtxMenu().exists()).toBe(true);
2020-04-08 14:13:33 +05:30
expect(wrapper.find({ ref: 'downloadCsvLink' }).exists()).toBe(true);
});
2020-03-13 15:44:24 +05:30
it('sets no clipboard copy link on dropdown by default', () => {
expect(findCopyLink().exists()).toBe(false);
});
2022-04-04 11:22:00 +05:30
it('should emit `timerange` event when a zooming in/out in a chart occcurs', async () => {
2020-04-22 19:07:51 +05:30
const timeRange = {
start: '2020-01-01T00:00:00.000Z',
end: '2020-01-01T01:00:00.000Z',
};
jest.spyOn(wrapper.vm, '$emit');
findTimeChart().vm.$emit('datazoom', timeRange);
2022-04-04 11:22:00 +05:30
await nextTick();
expect(wrapper.vm.$emit).toHaveBeenCalledWith('timerangezoom', timeRange);
2020-04-22 19:07:51 +05:30
});
2020-05-24 23:13:21 +05:30
it('includes a default group id', () => {
expect(wrapper.vm.groupId).toBe('dashboard-panel');
});
describe('Supports different panel types', () => {
2021-03-08 18:12:59 +05:30
const dataWithType = (type) => {
2020-05-24 23:13:21 +05:30
return {
...graphData,
type,
};
};
2020-03-13 15:44:24 +05:30
2020-05-24 23:13:21 +05:30
it('empty chart is rendered for empty results', () => {
createWrapper({ graphData: graphDataEmpty });
expect(wrapper.find(MonitorEmptyChart).exists()).toBe(true);
2020-03-13 15:44:24 +05:30
});
2020-05-24 23:13:21 +05:30
it('area chart is rendered by default', () => {
createWrapper();
expect(wrapper.find(MonitorTimeSeriesChart).exists()).toBe(true);
2020-03-13 15:44:24 +05:30
});
2020-07-28 23:09:34 +05:30
describe.each`
data | component | hasCtxMenu
${dataWithType(panelTypes.AREA_CHART)} | ${MonitorTimeSeriesChart} | ${true}
${dataWithType(panelTypes.LINE_CHART)} | ${MonitorTimeSeriesChart} | ${true}
${singleStatGraphData()} | ${MonitorSingleStatChart} | ${true}
${anomalyGraphData()} | ${MonitorAnomalyChart} | ${false}
${dataWithType(panelTypes.COLUMN)} | ${MonitorColumnChart} | ${false}
${dataWithType(panelTypes.STACKED_COLUMN)} | ${MonitorStackedColumnChart} | ${false}
2020-10-24 23:57:45 +05:30
${heatmapGraphData()} | ${MonitorHeatmapChart} | ${false}
2020-11-24 15:15:51 +05:30
${barGraphData()} | ${MonitorBarChart} | ${false}
2020-07-28 23:09:34 +05:30
`('when $data.type data is provided', ({ data, component, hasCtxMenu }) => {
2020-05-24 23:13:21 +05:30
const attrs = { attr1: 'attr1Value', attr2: 'attr2Value' };
2020-07-28 23:09:34 +05:30
beforeEach(() => {
createWrapper({ graphData: data }, { attrs });
});
it(`renders the chart component and binds attributes`, () => {
expect(wrapper.find(component).exists()).toBe(true);
expect(wrapper.find(component).attributes()).toMatchObject(attrs);
});
it(`contextual menu is ${hasCtxMenu ? '' : 'not '}shown`, () => {
expect(findCtxMenu().exists()).toBe(hasCtxMenu);
});
2020-03-13 15:44:24 +05:30
});
});
2020-10-24 23:57:45 +05:30
describe('computed', () => {
describe('fixedCurrentTimeRange', () => {
2022-04-04 11:22:00 +05:30
it('returns fixed time for valid time range', async () => {
2020-10-24 23:57:45 +05:30
state.timeRange = mockTimeRange;
2022-04-04 11:22:00 +05:30
await nextTick();
expect(findTimeChart().props('timeRange')).toEqual(
expect.objectContaining({
start: expect.any(String),
end: expect.any(String),
}),
);
2020-10-24 23:57:45 +05:30
});
it.each`
input | output
${''} | ${{}}
${undefined} | ${{}}
${null} | ${{}}
${'2020-12-03'} | ${{}}
2022-04-04 11:22:00 +05:30
`('returns $output for invalid input like $input', async ({ input, output }) => {
2020-10-24 23:57:45 +05:30
state.timeRange = input;
2022-04-04 11:22:00 +05:30
await nextTick();
expect(findTimeChart().props('timeRange')).toEqual(output);
2020-10-24 23:57:45 +05:30
});
});
});
2020-03-13 15:44:24 +05:30
});
2020-04-08 14:13:33 +05:30
describe('Edit custom metric dropdown item', () => {
const findEditCustomMetricLink = () => wrapper.find({ ref: 'editMetricLink' });
2020-05-24 23:13:21 +05:30
const mockEditPath = '/root/kubernetes-gke-project/prometheus/metrics/23/edit';
2020-04-08 14:13:33 +05:30
2022-04-04 11:22:00 +05:30
beforeEach(async () => {
2020-04-22 19:07:51 +05:30
createWrapper();
2022-04-04 11:22:00 +05:30
await nextTick();
2020-04-08 14:13:33 +05:30
});
it('is not present if the panel is not a custom metric', () => {
expect(findEditCustomMetricLink().exists()).toBe(false);
});
2022-04-04 11:22:00 +05:30
it('is present when the panel contains an edit_path property', async () => {
2020-04-08 14:13:33 +05:30
wrapper.setProps({
graphData: {
2020-04-22 19:07:51 +05:30
...graphData,
2020-04-08 14:13:33 +05:30
metrics: [
{
2020-04-22 19:07:51 +05:30
...graphData.metrics[0],
2020-05-24 23:13:21 +05:30
edit_path: mockEditPath,
2020-04-08 14:13:33 +05:30
},
],
},
});
2022-04-04 11:22:00 +05:30
await nextTick();
expect(findEditCustomMetricLink().exists()).toBe(true);
expect(findEditCustomMetricLink().text()).toBe('Edit metric');
expect(findEditCustomMetricLink().attributes('href')).toBe(mockEditPath);
2020-04-08 14:13:33 +05:30
});
2022-04-04 11:22:00 +05:30
it('shows an "Edit metrics" link pointing to settingsPath for a panel with multiple metrics', async () => {
2020-04-08 14:13:33 +05:30
wrapper.setProps({
graphData: {
2020-04-22 19:07:51 +05:30
...graphData,
2020-04-08 14:13:33 +05:30
metrics: [
{
2020-04-22 19:07:51 +05:30
...graphData.metrics[0],
2020-04-08 14:13:33 +05:30
edit_path: '/root/kubernetes-gke-project/prometheus/metrics/23/edit',
},
{
2020-04-22 19:07:51 +05:30
...graphData.metrics[0],
2020-04-08 14:13:33 +05:30
edit_path: '/root/kubernetes-gke-project/prometheus/metrics/23/edit',
},
],
},
});
2022-04-04 11:22:00 +05:30
await nextTick();
expect(findEditCustomMetricLink().text()).toBe('Edit metrics');
expect(findEditCustomMetricLink().attributes('href')).toBe(dashboardProps.settingsPath);
2020-04-08 14:13:33 +05:30
});
});
2020-03-13 15:44:24 +05:30
describe('View Logs dropdown item', () => {
const findViewLogsLink = () => wrapper.find({ ref: 'viewLogsLink' });
2022-04-04 11:22:00 +05:30
beforeEach(async () => {
2020-04-22 19:07:51 +05:30
createWrapper();
2022-04-04 11:22:00 +05:30
await nextTick();
2020-03-13 15:44:24 +05:30
});
2022-04-04 11:22:00 +05:30
it('is not present by default', async () => {
await nextTick();
expect(findViewLogsLink().exists()).toBe(false);
});
2020-03-13 15:44:24 +05:30
2022-04-04 11:22:00 +05:30
it('is not present if a time range is not set', async () => {
2020-03-13 15:44:24 +05:30
state.logsPath = mockLogsPath;
state.timeRange = null;
2022-04-04 11:22:00 +05:30
await nextTick();
expect(findViewLogsLink().exists()).toBe(false);
2020-03-13 15:44:24 +05:30
});
2022-04-04 11:22:00 +05:30
it('is not present if the logs path is default', async () => {
2020-03-13 15:44:24 +05:30
state.logsPath = invalidUrl;
state.timeRange = mockTimeRange;
2022-04-04 11:22:00 +05:30
await nextTick();
expect(findViewLogsLink().exists()).toBe(false);
2020-03-13 15:44:24 +05:30
});
2022-04-04 11:22:00 +05:30
it('is not present if the logs path is not set', async () => {
2020-03-13 15:44:24 +05:30
state.logsPath = null;
state.timeRange = mockTimeRange;
2022-04-04 11:22:00 +05:30
await nextTick();
expect(findViewLogsLink().exists()).toBe(false);
2020-03-13 15:44:24 +05:30
});
2022-04-04 11:22:00 +05:30
it('is present when logs path and time a range is present', async () => {
2020-03-13 15:44:24 +05:30
state.logsPath = mockLogsPath;
state.timeRange = mockTimeRange;
2022-04-04 11:22:00 +05:30
await nextTick();
expect(findViewLogsLink().attributes('href')).toMatch(mockLogsHref);
2020-03-13 15:44:24 +05:30
});
2022-07-16 23:28:13 +05:30
describe(':monitor_logging feature flag', () => {
it.each`
flagState | logsState | expected
${true} | ${'shows'} | ${true}
${false} | ${'hides'} | ${false}
`('$logsState logs when flag state is $flagState', async ({ flagState, expected }) => {
createWrapper({}, { provide: { glFeatures: { monitorLogging: flagState } } });
state.logsPath = mockLogsPath;
state.timeRange = mockTimeRange;
await nextTick();
expect(findViewLogsLink().exists()).toBe(expected);
});
});
2022-04-04 11:22:00 +05:30
it('it is overridden when a datazoom event is received', async () => {
2020-03-13 15:44:24 +05:30
state.logsPath = mockLogsPath;
state.timeRange = mockTimeRange;
const zoomedTimeRange = {
start: '2020-01-01T00:00:00.000Z',
end: '2020-01-01T01:00:00.000Z',
};
findTimeChart().vm.$emit('datazoom', zoomedTimeRange);
2022-04-04 11:22:00 +05:30
await nextTick();
const start = encodeURIComponent(zoomedTimeRange.start);
const end = encodeURIComponent(zoomedTimeRange.end);
expect(findViewLogsLink().attributes('href')).toMatch(
`${mockLogsPath}?start=${start}&end=${end}`,
);
2020-03-13 15:44:24 +05:30
});
});
2020-06-23 00:09:42 +05:30
describe('when clipboard data is available', () => {
2020-03-13 15:44:24 +05:30
const clipboardText = 'A value to copy.';
beforeEach(() => {
createWrapper({
clipboardText,
});
});
it('sets clipboard text on the dropdown', () => {
expect(findCopyLink().exists()).toBe(true);
expect(findCopyLink().element.dataset.clipboardText).toBe(clipboardText);
});
it('adds a copy button to the dropdown', () => {
2020-04-22 19:07:51 +05:30
expect(findCopyLink().text()).toContain('Copy link to chart');
2020-03-13 15:44:24 +05:30
});
it('opens a toast on click', () => {
findCopyLink().vm.$emit('click');
expect(wrapper.vm.$toast.show).toHaveBeenCalled();
});
});
2020-06-23 00:09:42 +05:30
describe('when clipboard data is not available', () => {
2020-05-24 23:13:21 +05:30
it('there is no "copy to clipboard" link for a null value', () => {
createWrapper({ clipboardText: null });
expect(findCopyLink().exists()).toBe(false);
});
it('there is no "copy to clipboard" link for an empty value', () => {
createWrapper({ clipboardText: '' });
expect(findCopyLink().exists()).toBe(false);
});
});
2020-03-13 15:44:24 +05:30
describe('when downloading metrics data as CSV', () => {
2022-04-04 11:22:00 +05:30
beforeEach(async () => {
2020-05-24 23:13:21 +05:30
wrapper = shallowMount(DashboardPanel, {
2020-03-13 15:44:24 +05:30
propsData: {
clipboardText: exampleText,
2020-07-28 23:09:34 +05:30
settingsPath: dashboardProps.settingsPath,
2020-04-22 19:07:51 +05:30
graphData: {
y_label: 'metric',
...graphData,
},
2020-03-13 15:44:24 +05:30
},
store,
});
2022-04-04 11:22:00 +05:30
await nextTick();
2020-03-13 15:44:24 +05:30
});
afterEach(() => {
wrapper.destroy();
});
describe('csvText', () => {
it('converts metrics data from json to csv', () => {
2020-10-24 23:57:45 +05:30
const header = `timestamp,"${graphData.y_label} > ${graphData.metrics[0].label}"`;
2020-04-22 19:07:51 +05:30
const data = graphData.metrics[0].result[0].values;
2020-03-13 15:44:24 +05:30
const firstRow = `${data[0][0]},${data[0][1]}`;
const secondRow = `${data[1][0]},${data[1][1]}`;
2020-04-22 19:07:51 +05:30
expect(wrapper.vm.csvText).toMatch(`${header}\r\n${firstRow}\r\n${secondRow}\r\n`);
2020-03-13 15:44:24 +05:30
});
});
describe('downloadCsv', () => {
it('produces a link with a Blob', () => {
expect(global.URL.createObjectURL).toHaveBeenLastCalledWith(expect.any(Blob));
expect(global.URL.createObjectURL).toHaveBeenLastCalledWith(
expect.objectContaining({
size: wrapper.vm.csvText.length,
type: 'text/plain',
}),
);
});
});
});
2020-04-22 19:07:51 +05:30
describe('when using dynamic modules', () => {
const { mockDeploymentData, mockProjectPath } = mockNamespacedData;
beforeEach(() => {
store = createEmbedGroupStore();
store.registerModule(mockNamespace, monitoringDashboard);
store.state.embedGroup.modules.push(mockNamespace);
2022-07-16 23:28:13 +05:30
createWrapper({ namespace: mockNamespace });
2020-04-22 19:07:51 +05:30
});
2022-04-04 11:22:00 +05:30
it('handles namespaced time range and logs path state', async () => {
2020-04-22 19:07:51 +05:30
store.state[mockNamespace].timeRange = mockTimeRange;
store.state[mockNamespace].logsPath = mockLogsPath;
2022-04-04 11:22:00 +05:30
await nextTick();
expect(wrapper.find({ ref: 'viewLogsLink' }).attributes().href).toBe(mockLogsHref);
2020-04-22 19:07:51 +05:30
});
2022-04-04 11:22:00 +05:30
it('handles namespaced deployment data state', async () => {
2020-04-22 19:07:51 +05:30
store.state[mockNamespace].deploymentData = mockDeploymentData;
2022-04-04 11:22:00 +05:30
await nextTick();
expect(findTimeChart().props().deploymentData).toEqual(mockDeploymentData);
2020-04-22 19:07:51 +05:30
});
2022-04-04 11:22:00 +05:30
it('handles namespaced project path state', async () => {
2020-04-22 19:07:51 +05:30
store.state[mockNamespace].projectPath = mockProjectPath;
2022-04-04 11:22:00 +05:30
await nextTick();
expect(findTimeChart().props().projectPath).toBe(mockProjectPath);
2020-04-22 19:07:51 +05:30
});
it('it renders a time series chart with no errors', () => {
2020-05-24 23:13:21 +05:30
expect(wrapper.find(MonitorTimeSeriesChart).exists()).toBe(true);
});
});
2020-06-23 00:09:42 +05:30
describe('panel timezone', () => {
it('displays a time chart in local timezone', () => {
createWrapper();
expect(findTimeChart().props('timezone')).toBe('LOCAL');
});
it('displays a heatmap in local timezone', () => {
2020-10-24 23:57:45 +05:30
createWrapper({ graphData: heatmapGraphData() });
2020-06-23 00:09:42 +05:30
expect(wrapper.find(MonitorHeatmapChart).props('timezone')).toBe('LOCAL');
});
describe('when timezone is set to UTC', () => {
beforeEach(() => {
store = createStore({ dashboardTimezone: 'UTC' });
});
it('displays a time chart with UTC', () => {
createWrapper();
expect(findTimeChart().props('timezone')).toBe('UTC');
});
it('displays a heatmap with UTC', () => {
2020-10-24 23:57:45 +05:30
createWrapper({ graphData: heatmapGraphData() });
2020-06-23 00:09:42 +05:30
expect(wrapper.find(MonitorHeatmapChart).props('timezone')).toBe('UTC');
});
});
});
2020-05-24 23:13:21 +05:30
describe('Expand to full screen', () => {
const findExpandBtn = () => wrapper.find({ ref: 'expandBtn' });
describe('when there is no @expand listener', () => {
it('does not show `View full screen` option', () => {
createWrapper();
expect(findExpandBtn().exists()).toBe(false);
});
});
describe('when there is an @expand listener', () => {
beforeEach(() => {
createWrapper({}, { listeners: { expand: () => {} } });
});
it('shows the `expand` option', () => {
expect(findExpandBtn().exists()).toBe(true);
});
it('emits the `expand` event', () => {
const preventDefault = jest.fn();
findExpandBtn().vm.$emit('click', { preventDefault });
expect(wrapper.emitted('expand')).toHaveLength(1);
expect(preventDefault).toHaveBeenCalled();
});
});
});
2020-06-23 00:09:42 +05:30
describe('When graphData contains links', () => {
const findManageLinksItem = () => wrapper.find({ ref: 'manageLinksItem' });
const mockLinks = [
{
url: 'https://example.com',
title: 'Example 1',
},
{
url: 'https://gitlab.com',
title: 'Example 2',
},
];
const createWrapperWithLinks = (links = mockLinks) => {
createWrapper({
graphData: {
...graphData,
links,
},
});
};
it('custom links are shown', () => {
createWrapperWithLinks();
mockLinks.forEach(({ url, title }) => {
const link = findMenuItemByText(title).at(0);
expect(link.exists()).toBe(true);
expect(link.attributes('href')).toBe(url);
});
});
it("custom links don't show unsecure content", () => {
createWrapperWithLinks([
{
title: '<script>alert("XSS")</script>',
url: 'http://example.com',
},
]);
expect(findMenuItems().at(1).element.innerHTML).toBe(
'&lt;script&gt;alert("XSS")&lt;/script&gt;',
);
});
it("custom links don't show unsecure href attributes", () => {
const title = 'Owned!';
createWrapperWithLinks([
{
title,
// eslint-disable-next-line no-script-url
url: 'javascript:alert("Evil")',
},
]);
const link = findMenuItemByText(title).at(0);
expect(link.attributes('href')).toBe('#');
});
it('when an editable dashboard is selected, shows `Manage chart links` link to the blob path', () => {
const editUrl = '/edit';
mockGetterReturnValue('selectedDashboard', {
can_edit: true,
project_blob_path: editUrl,
});
createWrapperWithLinks();
expect(findManageLinksItem().exists()).toBe(true);
expect(findManageLinksItem().attributes('href')).toBe(editUrl);
});
it('when no dashboard is selected, does not show `Manage chart links`', () => {
mockGetterReturnValue('selectedDashboard', null);
createWrapperWithLinks();
expect(findManageLinksItem().exists()).toBe(false);
});
it('when non-editable dashboard is selected, does not show `Manage chart links`', () => {
const editUrl = '/edit';
mockGetterReturnValue('selectedDashboard', {
can_edit: false,
project_blob_path: editUrl,
});
createWrapperWithLinks();
expect(findManageLinksItem().exists()).toBe(false);
});
});
2020-10-24 23:57:45 +05:30
describe('Runbook url', () => {
const findRunbookLinks = () => wrapper.findAll('[data-testid="runbookLink"]');
beforeEach(() => {
mockGetterReturnValue('metricsSavedToDb', []);
});
it('does not show a runbook link when alerts are not present', () => {
createWrapper();
expect(findRunbookLinks().length).toBe(0);
});
});
2020-03-13 15:44:24 +05:30
});