352 lines
8.4 KiB
JavaScript
352 lines
8.4 KiB
JavaScript
import Api from '~/api';
|
|
import MockAdapter from 'axios-mock-adapter';
|
|
import testAction from 'helpers/vuex_action_helper';
|
|
import axios from '~/lib/utils/axios_utils';
|
|
import createFlash from '~/flash';
|
|
import getInitialState from '~/ci_variable_list/store/state';
|
|
import * as actions from '~/ci_variable_list/store/actions';
|
|
import * as types from '~/ci_variable_list/store/mutation_types';
|
|
import mockData from '../services/mock_data';
|
|
import { prepareDataForDisplay, prepareEnvironments } from '~/ci_variable_list/store/utils';
|
|
|
|
jest.mock('~/api.js');
|
|
jest.mock('~/flash.js');
|
|
|
|
describe('CI variable list store actions', () => {
|
|
let mock;
|
|
let state;
|
|
const mockVariable = {
|
|
environment_scope: '*',
|
|
id: 63,
|
|
key: 'test_var',
|
|
masked: false,
|
|
protected: false,
|
|
value: 'test_val',
|
|
variable_type: 'env_var',
|
|
_destory: true,
|
|
};
|
|
const payloadError = new Error('Request failed with status code 500');
|
|
|
|
beforeEach(() => {
|
|
mock = new MockAdapter(axios);
|
|
state = getInitialState();
|
|
state.endpoint = '/variables';
|
|
});
|
|
|
|
afterEach(() => {
|
|
mock.restore();
|
|
});
|
|
|
|
describe('toggleValues', () => {
|
|
const valuesHidden = false;
|
|
it('commits TOGGLE_VALUES mutation', () => {
|
|
testAction(actions.toggleValues, valuesHidden, {}, [
|
|
{
|
|
type: types.TOGGLE_VALUES,
|
|
payload: valuesHidden,
|
|
},
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('clearModal', () => {
|
|
it('commits CLEAR_MODAL mutation', () => {
|
|
testAction(actions.clearModal, {}, {}, [
|
|
{
|
|
type: types.CLEAR_MODAL,
|
|
},
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('resetEditing', () => {
|
|
it('commits RESET_EDITING mutation', () => {
|
|
testAction(
|
|
actions.resetEditing,
|
|
{},
|
|
{},
|
|
[
|
|
{
|
|
type: types.RESET_EDITING,
|
|
},
|
|
],
|
|
[{ type: 'fetchVariables' }],
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('setVariableProtected', () => {
|
|
it('commits SET_VARIABLE_PROTECTED mutation', () => {
|
|
testAction(actions.setVariableProtected, {}, {}, [
|
|
{
|
|
type: types.SET_VARIABLE_PROTECTED,
|
|
},
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('deleteVariable', () => {
|
|
it('dispatch correct actions on successful deleted variable', done => {
|
|
mock.onPatch(state.endpoint).reply(200);
|
|
|
|
testAction(
|
|
actions.deleteVariable,
|
|
{},
|
|
state,
|
|
[],
|
|
[
|
|
{ type: 'requestDeleteVariable' },
|
|
{ type: 'receiveDeleteVariableSuccess' },
|
|
{ type: 'fetchVariables' },
|
|
],
|
|
() => {
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
|
|
it('should show flash error and set error in state on delete failure', done => {
|
|
mock.onPatch(state.endpoint).reply(500, '');
|
|
|
|
testAction(
|
|
actions.deleteVariable,
|
|
{},
|
|
state,
|
|
[],
|
|
[
|
|
{ type: 'requestDeleteVariable' },
|
|
{
|
|
type: 'receiveDeleteVariableError',
|
|
payload: payloadError,
|
|
},
|
|
],
|
|
() => {
|
|
expect(createFlash).toHaveBeenCalled();
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('updateVariable', () => {
|
|
it('dispatch correct actions on successful updated variable', done => {
|
|
mock.onPatch(state.endpoint).reply(200);
|
|
|
|
testAction(
|
|
actions.updateVariable,
|
|
{},
|
|
state,
|
|
[],
|
|
[
|
|
{ type: 'requestUpdateVariable' },
|
|
{ type: 'receiveUpdateVariableSuccess' },
|
|
{ type: 'fetchVariables' },
|
|
],
|
|
() => {
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
|
|
it('should show flash error and set error in state on update failure', done => {
|
|
mock.onPatch(state.endpoint).reply(500, '');
|
|
|
|
testAction(
|
|
actions.updateVariable,
|
|
mockVariable,
|
|
state,
|
|
[],
|
|
[
|
|
{ type: 'requestUpdateVariable' },
|
|
{
|
|
type: 'receiveUpdateVariableError',
|
|
payload: payloadError,
|
|
},
|
|
],
|
|
() => {
|
|
expect(createFlash).toHaveBeenCalled();
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('addVariable', () => {
|
|
it('dispatch correct actions on successful added variable', done => {
|
|
mock.onPatch(state.endpoint).reply(200);
|
|
|
|
testAction(
|
|
actions.addVariable,
|
|
{},
|
|
state,
|
|
[],
|
|
[
|
|
{ type: 'requestAddVariable' },
|
|
{ type: 'receiveAddVariableSuccess' },
|
|
{ type: 'fetchVariables' },
|
|
],
|
|
() => {
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
|
|
it('should show flash error and set error in state on add failure', done => {
|
|
mock.onPatch(state.endpoint).reply(500, '');
|
|
|
|
testAction(
|
|
actions.addVariable,
|
|
{},
|
|
state,
|
|
[],
|
|
[
|
|
{ type: 'requestAddVariable' },
|
|
{
|
|
type: 'receiveAddVariableError',
|
|
payload: payloadError,
|
|
},
|
|
],
|
|
() => {
|
|
expect(createFlash).toHaveBeenCalled();
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('fetchVariables', () => {
|
|
it('dispatch correct actions on fetchVariables', done => {
|
|
mock.onGet(state.endpoint).reply(200, { variables: mockData.mockVariables });
|
|
|
|
testAction(
|
|
actions.fetchVariables,
|
|
{},
|
|
state,
|
|
[],
|
|
[
|
|
{ type: 'requestVariables' },
|
|
{
|
|
type: 'receiveVariablesSuccess',
|
|
payload: prepareDataForDisplay(mockData.mockVariables),
|
|
},
|
|
],
|
|
() => {
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
|
|
it('should show flash error and set error in state on fetch variables failure', done => {
|
|
mock.onGet(state.endpoint).reply(500);
|
|
|
|
testAction(actions.fetchVariables, {}, state, [], [{ type: 'requestVariables' }], () => {
|
|
expect(createFlash).toHaveBeenCalledWith('There was an error fetching the variables.');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('fetchEnvironments', () => {
|
|
it('dispatch correct actions on fetchEnvironments', done => {
|
|
Api.environments = jest.fn().mockResolvedValue({ data: mockData.mockEnvironments });
|
|
|
|
testAction(
|
|
actions.fetchEnvironments,
|
|
{},
|
|
state,
|
|
[],
|
|
[
|
|
{ type: 'requestEnvironments' },
|
|
{
|
|
type: 'receiveEnvironmentsSuccess',
|
|
payload: prepareEnvironments(mockData.mockEnvironments),
|
|
},
|
|
],
|
|
() => {
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
|
|
it('should show flash error and set error in state on fetch environments failure', done => {
|
|
Api.environments = jest.fn().mockRejectedValue();
|
|
|
|
testAction(
|
|
actions.fetchEnvironments,
|
|
{},
|
|
state,
|
|
[],
|
|
[{ type: 'requestEnvironments' }],
|
|
() => {
|
|
expect(createFlash).toHaveBeenCalledWith(
|
|
'There was an error fetching the environments information.',
|
|
);
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('Update variable values', () => {
|
|
it('updateVariableKey', () => {
|
|
testAction(
|
|
actions.updateVariableKey,
|
|
{ key: mockVariable.key },
|
|
{},
|
|
[
|
|
{
|
|
type: types.UPDATE_VARIABLE_KEY,
|
|
payload: mockVariable.key,
|
|
},
|
|
],
|
|
[],
|
|
);
|
|
});
|
|
|
|
it('updateVariableValue', () => {
|
|
testAction(
|
|
actions.updateVariableValue,
|
|
{ secret_value: mockVariable.value },
|
|
{},
|
|
[
|
|
{
|
|
type: types.UPDATE_VARIABLE_VALUE,
|
|
payload: mockVariable.value,
|
|
},
|
|
],
|
|
[],
|
|
);
|
|
});
|
|
|
|
it('updateVariableType', () => {
|
|
testAction(
|
|
actions.updateVariableType,
|
|
{ variable_type: mockVariable.variable_type },
|
|
{},
|
|
[{ type: types.UPDATE_VARIABLE_TYPE, payload: mockVariable.variable_type }],
|
|
[],
|
|
);
|
|
});
|
|
|
|
it('updateVariableProtected', () => {
|
|
testAction(
|
|
actions.updateVariableProtected,
|
|
{ protected_variable: mockVariable.protected },
|
|
{},
|
|
[{ type: types.UPDATE_VARIABLE_PROTECTED, payload: mockVariable.protected }],
|
|
[],
|
|
);
|
|
});
|
|
|
|
it('updateVariableMasked', () => {
|
|
testAction(
|
|
actions.updateVariableMasked,
|
|
{ masked: mockVariable.masked },
|
|
{},
|
|
[{ type: types.UPDATE_VARIABLE_MASKED, payload: mockVariable.masked }],
|
|
[],
|
|
);
|
|
});
|
|
});
|
|
});
|