Merge branch 'winh-issue-boards-vuex-store-ee' into 'master'

Create empty Vuex store for issue boards (EE-port)

Closes gitlab-ce#61622

See merge request gitlab-org/gitlab-ee!12567

app/assets/javascripts/boards/stores/actions.js

+const notImplemented = () => {
+  throw new Error('Not implemented!');
+};
+
+export default {
+  setEndpoints: () => {
+    notImplemented();
+  },
+
+  fetchLists: () => {
+    notImplemented();
+  },
+
+  generateDefaultLists: () => {
+    notImplemented();
+  },
+
+  createList: () => {
+    notImplemented();
+  },
+
+  updateList: () => {
+    notImplemented();
+  },
+
+  deleteList: () => {
+    notImplemented();
+  },
+
+  fetchIssuesForList: () => {
+    notImplemented();
+  },
+
+  moveIssue: () => {
+    notImplemented();
+  },
+
+  createNewIssue: () => {
+    notImplemented();
+  },
+
+  fetchBacklog: () => {
+    notImplemented();
+  },
+
+  bulkUpdateIssues: () => {
+    notImplemented();
+  },
+
+  fetchIssue: () => {
+    notImplemented();
+  },
+
+  toggleIssueSubscription: () => {
+    notImplemented();
+  },
+
+  showPage: () => {
+    notImplemented();
+  },
+
+  toggleEmptyState: () => {
+    notImplemented();
+  },
+};

app/assets/javascripts/boards/stores/index.js

+import Vue from 'vue';
+import Vuex from 'vuex';
+import state from 'ee_else_ce/boards/stores/state';
+import actions from 'ee_else_ce/boards/stores/actions';
+import mutations from 'ee_else_ce/boards/stores/mutations';
+
+Vue.use(Vuex);
+
+export default () =>
+  new Vuex.Store({
+    state,
+    actions,
+    mutations,
+  });

app/assets/javascripts/boards/stores/mutation_types.js

+export const SET_ENDPOINTS = 'SET_ENDPOINTS';
+export const REQUEST_ADD_LIST = 'REQUEST_ADD_LIST';
+export const RECEIVE_ADD_LIST_SUCCESS = 'RECEIVE_ADD_LIST_SUCCESS';
+export const RECEIVE_ADD_LIST_ERROR = 'RECEIVE_ADD_LIST_ERROR';
+export const REQUEST_UPDATE_LIST = 'REQUEST_UPDATE_LIST';
+export const RECEIVE_UPDATE_LIST_SUCCESS = 'RECEIVE_UPDATE_LIST_SUCCESS';
+export const RECEIVE_UPDATE_LIST_ERROR = 'RECEIVE_UPDATE_LIST_ERROR';
+export const REQUEST_REMOVE_LIST = 'REQUEST_REMOVE_LIST';
+export const RECEIVE_REMOVE_LIST_SUCCESS = 'RECEIVE_REMOVE_LIST_SUCCESS';
+export const RECEIVE_REMOVE_LIST_ERROR = 'RECEIVE_REMOVE_LIST_ERROR';
+export const REQUEST_ADD_ISSUE = 'REQUEST_ADD_ISSUE';
+export const RECEIVE_ADD_ISSUE_SUCCESS = 'RECEIVE_ADD_ISSUE_SUCCESS';
+export const RECEIVE_ADD_ISSUE_ERROR = 'RECEIVE_ADD_ISSUE_ERROR';
+export const REQUEST_MOVE_ISSUE = 'REQUEST_MOVE_ISSUE';
+export const RECEIVE_MOVE_ISSUE_SUCCESS = 'RECEIVE_MOVE_ISSUE_SUCCESS';
+export const RECEIVE_MOVE_ISSUE_ERROR = 'RECEIVE_MOVE_ISSUE_ERROR';
+export const REQUEST_UPDATE_ISSUE = 'REQUEST_UPDATE_ISSUE';
+export const RECEIVE_UPDATE_ISSUE_SUCCESS = 'RECEIVE_UPDATE_ISSUE_SUCCESS';
+export const RECEIVE_UPDATE_ISSUE_ERROR = 'RECEIVE_UPDATE_ISSUE_ERROR';
+export const SET_CURRENT_PAGE = 'SET_CURRENT_PAGE';
+export const TOGGLE_EMPTY_STATE = 'TOGGLE_EMPTY_STATE';

app/assets/javascripts/boards/stores/mutations.js

+import * as mutationTypes from './mutation_types';
+
+const notImplemented = () => {
+  throw new Error('Not implemented!');
+};
+
+export default {
+  [mutationTypes.SET_ENDPOINTS]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.REQUEST_ADD_LIST]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_ADD_LIST_SUCCESS]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_ADD_LIST_ERROR]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.REQUEST_UPDATE_LIST]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_UPDATE_LIST_SUCCESS]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_UPDATE_LIST_ERROR]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.REQUEST_REMOVE_LIST]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_REMOVE_LIST_SUCCESS]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_REMOVE_LIST_ERROR]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.REQUEST_ADD_ISSUE]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_ADD_ISSUE_SUCCESS]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_ADD_ISSUE_ERROR]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.REQUEST_MOVE_ISSUE]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_MOVE_ISSUE_SUCCESS]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_MOVE_ISSUE_ERROR]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.REQUEST_UPDATE_ISSUE]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_UPDATE_ISSUE_SUCCESS]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_UPDATE_ISSUE_ERROR]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.SET_CURRENT_PAGE]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.TOGGLE_EMPTY_STATE]: () => {
+    notImplemented();
+  },
+};

app/assets/javascripts/boards/stores/state.js

+export default () => ({
+  // ...
+});

ee/app/assets/javascripts/boards/stores/actions.js

+import actionsCE from '~/boards/stores/actions';
+
+const notImplemented = () => {
+  throw new Error('Not implemented!');
+};
+
+export default {
+  ...actionsCE,
+
+  fetchAllBoards: () => {
+    notImplemented();
+  },
+
+  fetchRecentBoards: () => {
+    notImplemented();
+  },
+
+  createBoard: () => {
+    notImplemented();
+  },
+
+  deleteBoard: () => {
+    notImplemented();
+  },
+
+  updateIssueWeight: () => {
+    notImplemented();
+  },
+
+  togglePromotionState: () => {
+    notImplemented();
+  },
+};

ee/app/assets/javascripts/boards/stores/mutation_types.js

+export const REQUEST_AVAILABLE_BOARDS = 'REQUEST_AVAILABLE_BOARDS';
+export const RECEIVE_AVAILABLE_BOARDS_SUCCESS = 'RECEIVE_AVAILABLE_BOARDS_SUCCESS';
+export const RECEIVE_AVAILABLE_BOARDS_ERROR = 'RECEIVE_AVAILABLE_BOARDS_ERROR';
+export const REQUEST_RECENT_BOARDS = 'REQUEST_RECENT_BOARDS';
+export const RECEIVE_RECENT_BOARDS_SUCCESS = 'RECEIVE_RECENT_BOARDS_SUCCESS';
+export const RECEIVE_RECENT_BOARDS_ERROR = 'RECEIVE_RECENT_BOARDS_ERROR';
+export const REQUEST_ADD_BOARD = 'REQUEST_ADD_BOARD';
+export const RECEIVE_ADD_BOARD_SUCCESS = 'RECEIVE_ADD_BOARD_SUCCESS';
+export const RECEIVE_ADD_BOARD_ERROR = 'RECEIVE_ADD_BOARD_ERROR';
+export const REQUEST_REMOVE_BOARD = 'REQUEST_REMOVE_BOARD';
+export const RECEIVE_REMOVE_BOARD_SUCCESS = 'RECEIVE_REMOVE_BOARD_SUCCESS';
+export const RECEIVE_REMOVE_BOARD_ERROR = 'RECEIVE_REMOVE_BOARD_ERROR';
+export const TOGGLE_PROMOTION_STATE = 'TOGGLE_PROMOTION_STATE';

ee/app/assets/javascripts/boards/stores/mutations.js

+import * as mutationTypes from './mutation_types';
+
+const notImplemented = () => {
+  throw new Error('Not implemented!');
+};
+
+export default {
+  [mutationTypes.REQUEST_AVAILABLE_BOARDS]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_AVAILABLE_BOARDS_SUCCESS]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_AVAILABLE_BOARDS_ERROR]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.REQUEST_RECENT_BOARDS]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_RECENT_BOARDS_SUCCESS]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_RECENT_BOARDS_ERROR]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.REQUEST_ADD_BOARD]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_ADD_BOARD_SUCCESS]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_ADD_BOARD_ERROR]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.REQUEST_REMOVE_BOARD]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_REMOVE_BOARD_SUCCESS]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.RECEIVE_REMOVE_BOARD_ERROR]: () => {
+    notImplemented();
+  },
+
+  [mutationTypes.TOGGLE_PROMOTION_STATE]: () => {
+    notImplemented();
+  },
+};

ee/app/assets/javascripts/boards/stores/state.js

+import createStateCE from '~/boards/stores/state';
+
+export default () => ({
+  ...createStateCE(),
+
+  // ...
+});

ee/spec/frontend/boards/stores/actions_spec.js

+import actions from 'ee/boards/stores/actions';
+
+const expectNotImplemented = action => {
+  it('is not implemented', () => {
+    expect(action).toThrow(new Error('Not implemented!'));
+  });
+};
+
+describe('fetchAllBoards', () => {
+  expectNotImplemented(actions.fetchAllBoards);
+});
+
+describe('fetchRecentBoards', () => {
+  expectNotImplemented(actions.fetchRecentBoards);
+});
+
+describe('createBoard', () => {
+  expectNotImplemented(actions.createBoard);
+});
+
+describe('deleteBoard', () => {
+  expectNotImplemented(actions.deleteBoard);
+});
+
+describe('updateIssueWeight', () => {
+  expectNotImplemented(actions.updateIssueWeight);
+});
+
+describe('togglePromotionState', () => {
+  expectNotImplemented(actions.updateIssueWeight);
+});

ee/spec/frontend/boards/stores/mutations_spec.js

+import mutations from 'ee/boards/stores/mutations';
+
+const expectNotImplemented = action => {
+  it('is not implemented', () => {
+    expect(action).toThrow(new Error('Not implemented!'));
+  });
+};
+
+describe('REQUEST_AVAILABLE_BOARDS', () => {
+  expectNotImplemented(mutations.REQUEST_AVAILABLE_BOARDS);
+});
+
+describe('RECEIVE_AVAILABLE_BOARDS_SUCCESS', () => {
+  expectNotImplemented(mutations.RECEIVE_AVAILABLE_BOARDS_SUCCESS);
+});
+
+describe('RECEIVE_AVAILABLE_BOARDS_ERROR', () => {
+  expectNotImplemented(mutations.RECEIVE_AVAILABLE_BOARDS_ERROR);
+});
+
+describe('REQUEST_RECENT_BOARDS', () => {
+  expectNotImplemented(mutations.REQUEST_RECENT_BOARDS);
+});
+
+describe('RECEIVE_RECENT_BOARDS_SUCCESS', () => {
+  expectNotImplemented(mutations.RECEIVE_RECENT_BOARDS_SUCCESS);
+});
+
+describe('RECEIVE_RECENT_BOARDS_ERROR', () => {
+  expectNotImplemented(mutations.RECEIVE_RECENT_BOARDS_ERROR);
+});
+
+describe('REQUEST_ADD_BOARD', () => {
+  expectNotImplemented(mutations.REQUEST_ADD_BOARD);
+});
+
+describe('RECEIVE_ADD_BOARD_SUCCESS', () => {
+  expectNotImplemented(mutations.RECEIVE_ADD_BOARD_SUCCESS);
+});
+
+describe('RECEIVE_ADD_BOARD_ERROR', () => {
+  expectNotImplemented(mutations.RECEIVE_ADD_BOARD_ERROR);
+});
+
+describe('REQUEST_REMOVE_BOARD', () => {
+  expectNotImplemented(mutations.REQUEST_REMOVE_BOARD);
+});
+
+describe('RECEIVE_REMOVE_BOARD_SUCCESS', () => {
+  expectNotImplemented(mutations.RECEIVE_REMOVE_BOARD_SUCCESS);
+});
+
+describe('RECEIVE_REMOVE_BOARD_ERROR', () => {
+  expectNotImplemented(mutations.RECEIVE_REMOVE_BOARD_ERROR);
+});
+
+describe('TOGGLE_PROMOTION_STATE', () => {
+  expectNotImplemented(mutations.TOGGLE_PROMOTION_STATE);
+});

ee/spec/frontend/boards/stores/state_spec.js

+import createState from 'ee/boards/stores/state';
+import createStateCE from '~/boards/stores/state';
+
+describe('createState', () => {
+  it('is a function', () => {
+    expect(createState).toEqual(expect.any(Function));
+  });
+
+  it('returns an object', () => {
+    expect(createState()).toEqual(expect.any(Object));
+  });
+
+  it('contains the CE state', () => {
+    expect(createState()).toEqual(expect.objectContaining(createStateCE()));
+  });
+});

spec/frontend/boards/stores/actions_spec.js

+import actions from '~/boards/stores/actions';
+
+const expectNotImplemented = action => {
+  it('is not implemented', () => {
+    expect(action).toThrow(new Error('Not implemented!'));
+  });
+};
+
+describe('setEndpoints', () => {
+  expectNotImplemented(actions.setEndpoints);
+});
+
+describe('fetchLists', () => {
+  expectNotImplemented(actions.fetchLists);
+});
+
+describe('generateDefaultLists', () => {
+  expectNotImplemented(actions.generateDefaultLists);
+});
+
+describe('createList', () => {
+  expectNotImplemented(actions.createList);
+});
+
+describe('updateList', () => {
+  expectNotImplemented(actions.updateList);
+});
+
+describe('deleteList', () => {
+  expectNotImplemented(actions.deleteList);
+});
+
+describe('fetchIssuesForList', () => {
+  expectNotImplemented(actions.fetchIssuesForList);
+});
+
+describe('moveIssue', () => {
+  expectNotImplemented(actions.moveIssue);
+});
+
+describe('createNewIssue', () => {
+  expectNotImplemented(actions.createNewIssue);
+});
+
+describe('fetchBacklog', () => {
+  expectNotImplemented(actions.fetchBacklog);
+});
+
+describe('bulkUpdateIssues', () => {
+  expectNotImplemented(actions.bulkUpdateIssues);
+});
+
+describe('fetchIssue', () => {
+  expectNotImplemented(actions.fetchIssue);
+});
+
+describe('toggleIssueSubscription', () => {
+  expectNotImplemented(actions.toggleIssueSubscription);
+});
+
+describe('showPage', () => {
+  expectNotImplemented(actions.showPage);
+});
+
+describe('toggleEmptyState', () => {
+  expectNotImplemented(actions.toggleEmptyState);
+});

spec/frontend/boards/stores/mutations_spec.js

+import mutations from '~/boards/stores/mutations';
+
+const expectNotImplemented = action => {
+  it('is not implemented', () => {
+    expect(action).toThrow(new Error('Not implemented!'));
+  });
+};
+
+describe('SET_ENDPOINTS', () => {
+  expectNotImplemented(mutations.SET_ENDPOINTS);
+});
+
+describe('REQUEST_ADD_LIST', () => {
+  expectNotImplemented(mutations.REQUEST_ADD_LIST);
+});
+
+describe('RECEIVE_ADD_LIST_SUCCESS', () => {
+  expectNotImplemented(mutations.RECEIVE_ADD_LIST_SUCCESS);
+});
+
+describe('RECEIVE_ADD_LIST_ERROR', () => {
+  expectNotImplemented(mutations.RECEIVE_ADD_LIST_ERROR);
+});
+
+describe('REQUEST_UPDATE_LIST', () => {
+  expectNotImplemented(mutations.REQUEST_UPDATE_LIST);
+});
+
+describe('RECEIVE_UPDATE_LIST_SUCCESS', () => {
+  expectNotImplemented(mutations.RECEIVE_UPDATE_LIST_SUCCESS);
+});
+
+describe('RECEIVE_UPDATE_LIST_ERROR', () => {
+  expectNotImplemented(mutations.RECEIVE_UPDATE_LIST_ERROR);
+});
+
+describe('REQUEST_REMOVE_LIST', () => {
+  expectNotImplemented(mutations.REQUEST_REMOVE_LIST);
+});
+
+describe('RECEIVE_REMOVE_LIST_SUCCESS', () => {
+  expectNotImplemented(mutations.RECEIVE_REMOVE_LIST_SUCCESS);
+});
+
+describe('RECEIVE_REMOVE_LIST_ERROR', () => {
+  expectNotImplemented(mutations.RECEIVE_REMOVE_LIST_ERROR);
+});
+
+describe('REQUEST_ADD_ISSUE', () => {
+  expectNotImplemented(mutations.REQUEST_ADD_ISSUE);
+});
+
+describe('RECEIVE_ADD_ISSUE_SUCCESS', () => {
+  expectNotImplemented(mutations.RECEIVE_ADD_ISSUE_SUCCESS);
+});
+
+describe('RECEIVE_ADD_ISSUE_ERROR', () => {
+  expectNotImplemented(mutations.RECEIVE_ADD_ISSUE_ERROR);
+});
+
+describe('REQUEST_MOVE_ISSUE', () => {
+  expectNotImplemented(mutations.REQUEST_MOVE_ISSUE);
+});
+
+describe('RECEIVE_MOVE_ISSUE_SUCCESS', () => {
+  expectNotImplemented(mutations.RECEIVE_MOVE_ISSUE_SUCCESS);
+});
+
+describe('RECEIVE_MOVE_ISSUE_ERROR', () => {
+  expectNotImplemented(mutations.RECEIVE_MOVE_ISSUE_ERROR);
+});
+
+describe('REQUEST_UPDATE_ISSUE', () => {
+  expectNotImplemented(mutations.REQUEST_UPDATE_ISSUE);
+});
+
+describe('RECEIVE_UPDATE_ISSUE_SUCCESS', () => {
+  expectNotImplemented(mutations.RECEIVE_UPDATE_ISSUE_SUCCESS);
+});
+
+describe('RECEIVE_UPDATE_ISSUE_ERROR', () => {
+  expectNotImplemented(mutations.RECEIVE_UPDATE_ISSUE_ERROR);
+});
+
+describe('SET_CURRENT_PAGE', () => {
+  expectNotImplemented(mutations.SET_CURRENT_PAGE);
+});
+
+describe('TOGGLE_EMPTY_STATE', () => {
+  expectNotImplemented(mutations.TOGGLE_EMPTY_STATE);
+});

spec/frontend/boards/stores/state_spec.js

+import createState from '~/boards/stores/state';
+
+describe('createState', () => {
+  it('is a function', () => {
+    expect(createState).toEqual(expect.any(Function));
+  });
+
+  it('returns an object', () => {
+    expect(createState()).toEqual(expect.any(Object));
+  });
+});