debian-mirror-gitlab/spec/frontend/monitoring/store/getters_spec.js

405 lines
12 KiB
JavaScript
Raw Normal View History

2020-04-22 19:07:51 +05:30
import _ from 'lodash';
2020-01-01 13:55:28 +05:30
import * as getters from '~/monitoring/stores/getters';
import mutations from '~/monitoring/stores/mutations';
import * as types from '~/monitoring/stores/mutation_types';
import { metricStates } from '~/monitoring/constants';
2020-05-24 23:13:21 +05:30
import {
environmentData,
metricsResult,
dashboardGitResponse,
mockTemplatingDataResponses,
} from '../mock_data';
2020-01-01 13:55:28 +05:30
import {
2020-04-22 19:07:51 +05:30
metricsDashboardPayload,
metricResultStatus,
metricResultPods,
metricResultEmpty,
} from '../fixture_data';
2020-01-01 13:55:28 +05:30
describe('Monitoring store Getters', () => {
describe('getMetricStates', () => {
let setupState;
let state;
let getMetricStates;
2020-04-22 19:07:51 +05:30
const setMetricSuccess = ({ result = metricsResult, group = 0, panel = 0, metric = 0 }) => {
const { metricId } = state.dashboard.panelGroups[group].panels[panel].metrics[metric];
mutations[types.RECEIVE_METRIC_RESULT_SUCCESS](state, {
metricId,
result,
});
};
const setMetricFailure = ({ group = 0, panel = 0, metric = 0 }) => {
const { metricId } = state.dashboard.panelGroups[group].panels[panel].metrics[metric];
mutations[types.RECEIVE_METRIC_RESULT_FAILURE](state, {
metricId,
});
};
2020-01-01 13:55:28 +05:30
beforeEach(() => {
setupState = (initState = {}) => {
state = initState;
getMetricStates = getters.getMetricStates(state);
};
});
it('has method-style access', () => {
setupState();
expect(getMetricStates).toEqual(expect.any(Function));
});
it('when dashboard has no panel groups, returns empty', () => {
setupState({
dashboard: {
2020-04-08 14:13:33 +05:30
panelGroups: [],
2020-01-01 13:55:28 +05:30
},
});
expect(getMetricStates()).toEqual([]);
});
describe('when the dashboard is set', () => {
let groups;
beforeEach(() => {
setupState({
2020-04-08 14:13:33 +05:30
dashboard: { panelGroups: [] },
2020-01-01 13:55:28 +05:30
});
2020-04-22 19:07:51 +05:30
mutations[types.RECEIVE_METRICS_DASHBOARD_SUCCESS](state, metricsDashboardPayload);
2020-04-08 14:13:33 +05:30
groups = state.dashboard.panelGroups;
2020-01-01 13:55:28 +05:30
});
it('no loaded metric returns empty', () => {
expect(getMetricStates()).toEqual([]);
});
it('on an empty metric with no result, returns NO_DATA', () => {
2020-04-22 19:07:51 +05:30
mutations[types.RECEIVE_METRICS_DASHBOARD_SUCCESS](state, metricsDashboardPayload);
setMetricSuccess({ result: [], group: 2 });
2020-01-01 13:55:28 +05:30
expect(getMetricStates()).toEqual([metricStates.NO_DATA]);
});
it('on a metric with a result, returns OK', () => {
2020-04-22 19:07:51 +05:30
mutations[types.RECEIVE_METRICS_DASHBOARD_SUCCESS](state, metricsDashboardPayload);
setMetricSuccess({ group: 1 });
2020-01-01 13:55:28 +05:30
expect(getMetricStates()).toEqual([metricStates.OK]);
});
it('on a metric with an error, returns an error', () => {
2020-04-22 19:07:51 +05:30
mutations[types.RECEIVE_METRICS_DASHBOARD_SUCCESS](state, metricsDashboardPayload);
setMetricFailure({});
2020-01-01 13:55:28 +05:30
expect(getMetricStates()).toEqual([metricStates.UNKNOWN_ERROR]);
});
it('on multiple metrics with results, returns OK', () => {
2020-04-22 19:07:51 +05:30
mutations[types.RECEIVE_METRICS_DASHBOARD_SUCCESS](state, metricsDashboardPayload);
setMetricSuccess({ group: 1 });
setMetricSuccess({ group: 1, panel: 1 });
2020-01-01 13:55:28 +05:30
expect(getMetricStates()).toEqual([metricStates.OK]);
// Filtered by groups
2020-04-08 14:13:33 +05:30
expect(getMetricStates(state.dashboard.panelGroups[1].key)).toEqual([metricStates.OK]);
expect(getMetricStates(state.dashboard.panelGroups[2].key)).toEqual([]);
2020-01-01 13:55:28 +05:30
});
it('on multiple metrics errors', () => {
2020-04-22 19:07:51 +05:30
mutations[types.RECEIVE_METRICS_DASHBOARD_SUCCESS](state, metricsDashboardPayload);
2020-01-01 13:55:28 +05:30
2020-04-22 19:07:51 +05:30
setMetricFailure({});
setMetricFailure({ group: 1 });
2020-01-01 13:55:28 +05:30
// Entire dashboard fails
expect(getMetricStates()).toEqual([metricStates.UNKNOWN_ERROR]);
expect(getMetricStates(groups[0].key)).toEqual([metricStates.UNKNOWN_ERROR]);
expect(getMetricStates(groups[1].key)).toEqual([metricStates.UNKNOWN_ERROR]);
});
it('on multiple metrics with errors', () => {
2020-04-22 19:07:51 +05:30
mutations[types.RECEIVE_METRICS_DASHBOARD_SUCCESS](state, metricsDashboardPayload);
2020-01-01 13:55:28 +05:30
// An success in 1 group
2020-04-22 19:07:51 +05:30
setMetricSuccess({ group: 1 });
2020-01-01 13:55:28 +05:30
// An error in 2 groups
2020-04-22 19:07:51 +05:30
setMetricFailure({ group: 1, panel: 1 });
setMetricFailure({ group: 2, panel: 0 });
2020-01-01 13:55:28 +05:30
expect(getMetricStates()).toEqual([metricStates.OK, metricStates.UNKNOWN_ERROR]);
expect(getMetricStates(groups[1].key)).toEqual([
metricStates.OK,
metricStates.UNKNOWN_ERROR,
]);
2020-04-08 14:13:33 +05:30
expect(getMetricStates(groups[2].key)).toEqual([metricStates.UNKNOWN_ERROR]);
2020-01-01 13:55:28 +05:30
});
});
});
describe('metricsWithData', () => {
let metricsWithData;
let setupState;
let state;
beforeEach(() => {
setupState = (initState = {}) => {
state = initState;
metricsWithData = getters.metricsWithData(state);
};
});
afterEach(() => {
state = null;
});
it('has method-style access', () => {
setupState();
expect(metricsWithData).toEqual(expect.any(Function));
});
it('when dashboard has no panel groups, returns empty', () => {
setupState({
dashboard: {
2020-04-08 14:13:33 +05:30
panelGroups: [],
2020-01-01 13:55:28 +05:30
},
});
expect(metricsWithData()).toEqual([]);
});
describe('when the dashboard is set', () => {
beforeEach(() => {
setupState({
2020-04-08 14:13:33 +05:30
dashboard: { panelGroups: [] },
2020-01-01 13:55:28 +05:30
});
});
it('no loaded metric returns empty', () => {
2020-04-22 19:07:51 +05:30
mutations[types.RECEIVE_METRICS_DASHBOARD_SUCCESS](state, metricsDashboardPayload);
2020-01-01 13:55:28 +05:30
expect(metricsWithData()).toEqual([]);
});
it('an empty metric, returns empty', () => {
2020-04-22 19:07:51 +05:30
mutations[types.RECEIVE_METRICS_DASHBOARD_SUCCESS](state, metricsDashboardPayload);
mutations[types.RECEIVE_METRIC_RESULT_SUCCESS](state, metricResultEmpty);
2020-01-01 13:55:28 +05:30
expect(metricsWithData()).toEqual([]);
});
it('a metric with results, it returns a metric', () => {
2020-04-22 19:07:51 +05:30
mutations[types.RECEIVE_METRICS_DASHBOARD_SUCCESS](state, metricsDashboardPayload);
mutations[types.RECEIVE_METRIC_RESULT_SUCCESS](state, metricResultStatus);
2020-01-01 13:55:28 +05:30
2020-04-22 19:07:51 +05:30
expect(metricsWithData()).toEqual([metricResultStatus.metricId]);
2020-01-01 13:55:28 +05:30
});
it('multiple metrics with results, it return multiple metrics', () => {
2020-04-22 19:07:51 +05:30
mutations[types.RECEIVE_METRICS_DASHBOARD_SUCCESS](state, metricsDashboardPayload);
mutations[types.RECEIVE_METRIC_RESULT_SUCCESS](state, metricResultStatus);
mutations[types.RECEIVE_METRIC_RESULT_SUCCESS](state, metricResultPods);
2020-01-01 13:55:28 +05:30
2020-04-22 19:07:51 +05:30
expect(metricsWithData()).toEqual([metricResultStatus.metricId, metricResultPods.metricId]);
2020-01-01 13:55:28 +05:30
});
it('multiple metrics with results, it returns metrics filtered by group', () => {
2020-04-22 19:07:51 +05:30
mutations[types.RECEIVE_METRICS_DASHBOARD_SUCCESS](state, metricsDashboardPayload);
mutations[types.RECEIVE_METRIC_RESULT_SUCCESS](state, metricResultStatus);
mutations[types.RECEIVE_METRIC_RESULT_SUCCESS](state, metricResultPods);
2020-01-01 13:55:28 +05:30
2020-04-08 14:13:33 +05:30
// First group has metrics
expect(metricsWithData(state.dashboard.panelGroups[1].key)).toEqual([
2020-04-22 19:07:51 +05:30
metricResultStatus.metricId,
metricResultPods.metricId,
2020-01-01 13:55:28 +05:30
]);
2020-04-08 14:13:33 +05:30
// Second group has no metrics
expect(metricsWithData(state.dashboard.panelGroups[2].key)).toEqual([]);
2020-01-01 13:55:28 +05:30
});
});
});
2020-03-13 15:44:24 +05:30
describe('filteredEnvironments', () => {
let state;
const setupState = (initState = {}) => {
state = {
...state,
...initState,
};
};
beforeAll(() => {
setupState({
environments: environmentData,
});
});
afterAll(() => {
state = null;
});
[
{
input: '',
output: 17,
},
{
input: ' ',
output: 17,
},
{
input: null,
output: 17,
},
{
input: 'does-not-exist',
output: 0,
},
{
input: 'noop-branch-',
output: 15,
},
{
input: 'noop-branch-9',
output: 1,
},
].forEach(({ input, output }) => {
it(`filteredEnvironments returns ${output} items for ${input}`, () => {
setupState({
environmentsSearchTerm: input,
});
expect(getters.filteredEnvironments(state).length).toBe(output);
});
});
});
2020-04-22 19:07:51 +05:30
describe('metricsSavedToDb', () => {
let metricsSavedToDb;
let state;
let mockData;
beforeEach(() => {
mockData = _.cloneDeep(metricsDashboardPayload);
state = {
dashboard: {
panelGroups: [],
},
};
});
it('return no metrics when dashboard is not persisted', () => {
mutations[types.RECEIVE_METRICS_DASHBOARD_SUCCESS](state, mockData);
metricsSavedToDb = getters.metricsSavedToDb(state);
expect(metricsSavedToDb).toEqual([]);
});
it('return a metric id when one metric is persisted', () => {
const id = 99;
const [metric] = mockData.panel_groups[0].panels[0].metrics;
metric.metric_id = id;
mutations[types.RECEIVE_METRICS_DASHBOARD_SUCCESS](state, mockData);
metricsSavedToDb = getters.metricsSavedToDb(state);
expect(metricsSavedToDb).toEqual([`${id}_${metric.id}`]);
});
it('return a metric id when two metrics are persisted', () => {
const id1 = 101;
const id2 = 102;
const [metric1] = mockData.panel_groups[0].panels[0].metrics;
const [metric2] = mockData.panel_groups[0].panels[1].metrics;
// database persisted 2 metrics
metric1.metric_id = id1;
metric2.metric_id = id2;
mutations[types.RECEIVE_METRICS_DASHBOARD_SUCCESS](state, mockData);
metricsSavedToDb = getters.metricsSavedToDb(state);
expect(metricsSavedToDb).toEqual([`${id1}_${metric1.id}`, `${id2}_${metric2.id}`]);
});
});
2020-05-24 23:13:21 +05:30
2020-05-30 21:06:31 +05:30
describe('getCustomVariablesParams', () => {
2020-05-24 23:13:21 +05:30
let state;
beforeEach(() => {
state = {
promVariables: {},
};
});
it('transforms the promVariables object to an array in the [variable, variable_value] format for all variable types', () => {
mutations[types.SET_VARIABLES](state, mockTemplatingDataResponses.allVariableTypes);
2020-05-30 21:06:31 +05:30
const variablesArray = getters.getCustomVariablesParams(state);
expect(variablesArray).toEqual({
'variables[advCustomNormal]': 'value2',
'variables[advText]': 'default',
'variables[simpleCustom]': 'value1',
'variables[simpleText]': 'Simple text',
});
2020-05-24 23:13:21 +05:30
});
it('transforms the promVariables object to an empty array when no keys are present', () => {
mutations[types.SET_VARIABLES](state, {});
2020-05-30 21:06:31 +05:30
const variablesArray = getters.getCustomVariablesParams(state);
2020-05-24 23:13:21 +05:30
2020-05-30 21:06:31 +05:30
expect(variablesArray).toEqual({});
2020-05-24 23:13:21 +05:30
});
});
describe('selectedDashboard', () => {
const { selectedDashboard } = getters;
it('returns a dashboard', () => {
const state = {
allDashboards: dashboardGitResponse,
currentDashboard: dashboardGitResponse[0].path,
};
expect(selectedDashboard(state)).toEqual(dashboardGitResponse[0]);
});
it('returns a non-default dashboard', () => {
const state = {
allDashboards: dashboardGitResponse,
currentDashboard: dashboardGitResponse[1].path,
};
expect(selectedDashboard(state)).toEqual(dashboardGitResponse[1]);
});
it('returns a default dashboard when no dashboard is selected', () => {
const state = {
allDashboards: dashboardGitResponse,
currentDashboard: null,
};
expect(selectedDashboard(state)).toEqual(dashboardGitResponse[0]);
});
it('returns a default dashboard when dashboard cannot be found', () => {
const state = {
allDashboards: dashboardGitResponse,
currentDashboard: 'wrong_path',
};
expect(selectedDashboard(state)).toEqual(dashboardGitResponse[0]);
});
it('returns null when no dashboards are present', () => {
const state = {
allDashboards: [],
currentDashboard: dashboardGitResponse[0].path,
};
expect(selectedDashboard(state)).toEqual(null);
});
});
2020-01-01 13:55:28 +05:30
});