foreman_webhooks 0.0.1

data/webpack/ForemanWebhooks/Routes/Webhooks/WebhooksIndexPage/__tests__/WebhooksIndexPage.test.js

@@ -0,0 +1,21 @@
+import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import WebhooksIndexPage from '../WebhooksIndexPage';
+
+const fixtures = {
+  'render with minimal props': {
+    fetchAndPush: () => {},
+    isLoading: false,
+    hasError: false,
+    hasData: false,
+    itemCount: 0,
+    canCreate: true,
+    sort: {},
+    webhooks: [],
+    toasts: [],
+  },
+};
+
+describe('WebhooksIndexPage', () => {
+  describe('redering', () =>
+    testComponentSnapshotsWithFixtures(WebhooksIndexPage, fixtures));
+});

data/webpack/ForemanWebhooks/Routes/Webhooks/WebhooksIndexPage/__tests__/__snapshots__/WebhooksIndexPage.test.js.snap

@@ -0,0 +1,68 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`WebhooksIndexPage redering render with minimal props 1`] = `
+<PageLayout
+  header="Webhooks"
+  isLoading={false}
+  onBookmarkClick={[Function]}
+  onSearch={[Function]}
+  searchProps={
+    Object {
+      "autocomplete": Object {
+        "id": "searchBar",
+        "searchQuery": "",
+        "url": "webhooks/auto_complete_search",
+        "useKeyShortcuts": true,
+      },
+      "bookmarks": Object {
+        "canCreateBookmarks": true,
+        "documentationUrl": "4.1.5Searching",
+        "url": "/api/bookmarks",
+      },
+      "controller": "webhooks",
+    }
+  }
+  searchQuery=""
+  searchable={true}
+  toastNotifications={Array []}
+  toolbarButtons={
+    <ForwardRef
+      to=""
+    >
+      <Button
+        active={false}
+        block={false}
+        bsClass="btn"
+        bsStyle="primary"
+        disabled={false}
+      >
+        Create Webhook
+      </Button>
+    </ForwardRef>
+  }
+>
+  <WrappedWebhooksTable
+    fetchAndPush={[Function]}
+    hasData={false}
+    hasError={false}
+    isLoading={false}
+    itemCount={0}
+    message={
+      Object {
+        "text": "Try to create a new Webhook",
+        "type": "empty",
+      }
+    }
+    pagination={
+      Object {
+        "page": null,
+        "perPage": null,
+      }
+    }
+    results={Array []}
+    setToDelete={[Function]}
+    sort={Object {}}
+    toDelete={Object {}}
+  />
+</PageLayout>
+`;

data/webpack/ForemanWebhooks/Routes/Webhooks/WebhooksIndexPage/index.js

@@ -0,0 +1,51 @@
+import React from 'react';
+import { connect } from 'react-redux';
+import { compose, bindActionCreators } from 'redux';
+
+import { callOnMount, callOnPopState } from 'foremanReact/common/HOC';
+import { useForemanContext } from 'foremanReact/Root/Context/ForemanContext';
+
+import WebhooksIndexPage from './WebhooksIndexPage';
+import * as actions from '../WebhooksPageActions';
+
+import {
+  selectWebhooks,
+  selectPage,
+  selectPerPage,
+  selectSearch,
+  selectSort,
+  selectHasData,
+  selectHasError,
+  selectIsLoading,
+  selectSubtotal,
+  selectMessage,
+  selectCanCreate,
+} from '../WebhooksPageSelectors';
+
+const mapStateToProps = state => ({
+  webhooks: selectWebhooks(state),
+  page: selectPage(state),
+  perPage: selectPerPage(state),
+  search: selectSearch(state),
+  sort: selectSort(state),
+  isLoading: selectIsLoading(state),
+  hasData: selectHasData(state),
+  hasError: selectHasError(state),
+  itemCount: selectSubtotal(state),
+  message: selectMessage(state),
+  canCreate: selectCanCreate(state),
+});
+
+const mapDispatchToProps = dispatch => bindActionCreators(actions, dispatch);
+
+const callWithToastsContext = Component => props => {
+  const { toasts } = useForemanContext();
+  return <Component {...props} toasts={toasts} />;
+};
+
+export default compose(
+  connect(mapStateToProps, mapDispatchToProps),
+  callWithToastsContext,
+  callOnMount(({ initializeWebhooks }) => initializeWebhooks()),
+  callOnPopState(({ fetchWebhooks }) => fetchWebhooks())
+)(WebhooksIndexPage);

data/webpack/ForemanWebhooks/Routes/Webhooks/WebhooksPageActions.js

@@ -0,0 +1,51 @@
+import history from 'foremanReact/history';
+import { get } from 'foremanReact/redux/API';
+import { stringifyParams, getParams } from 'foremanReact/common/urlHelpers';
+
+import { buildQuery } from './WebhooksPageHelpers';
+import {
+  WEBHOOKS_API_PATH,
+  WEBHOOKS_PATH,
+  WEBHOOKS_API_REQUEST_KEY,
+} from './constants';
+
+export const initializeWebhooks = () => dispatch => {
+  const params = getParams();
+  dispatch(fetchWebhooks(params));
+  if (!history.action === 'POP') {
+    history.replace({
+      pathname: WEBHOOKS_PATH,
+      search: stringifyParams(params),
+    });
+  }
+};
+
+export const fetchWebhooks = (
+  { page, perPage, searchQuery, sort },
+  url = WEBHOOKS_API_PATH
+) => async dispatch => {
+  const sortString =
+    sort && Object.keys(sort).length > 0 ? `${sort.by} ${sort.order}` : '';
+
+  return dispatch(
+    get({
+      key: WEBHOOKS_API_REQUEST_KEY,
+      url,
+      params: {
+        page,
+        per_page: perPage,
+        search: searchQuery,
+        order: sortString,
+      },
+    })
+  );
+};
+
+export const fetchAndPush = (params = {}) => (dispatch, getState) => {
+  const query = buildQuery(params, getState());
+  dispatch(fetchWebhooks(query));
+  history.push({
+    pathname: WEBHOOKS_PATH,
+    search: stringifyParams(query),
+  });
+};

data/webpack/ForemanWebhooks/Routes/Webhooks/WebhooksPageHelpers.js

@@ -0,0 +1,29 @@
+import { snakeCase } from 'lodash';
+import { compose } from 'redux';
+import {
+  selectSort,
+  selectPage,
+  selectPerPage,
+  selectSearch,
+} from './WebhooksPageSelectors';
+
+export const buildQuery = (query, state) => {
+  const querySort = pickSort(query, state);
+
+  return {
+    page: query.page || selectPage(state),
+    perPage: query.perPage || selectPerPage(state),
+    searchQuery:
+      query.searchQuery === undefined ? selectSearch(state) : query.searchQuery,
+    ...(querySort && { sort: querySort }),
+  };
+};
+
+export const pickSort = (query, state) =>
+  checkSort(query.sort)
+    ? transformSort(query.sort)
+    : checkSort(compose(transformSort, selectSort)(state));
+
+const checkSort = sort => (sort && sort.by && sort.order ? sort : undefined);
+
+const transformSort = sort => ({ ...sort, by: snakeCase(sort.by) });

data/webpack/ForemanWebhooks/Routes/Webhooks/WebhooksPageSelectors.js

@@ -0,0 +1,85 @@
+import { camelCase, isEmpty } from 'lodash';
+import Immutable from 'seamless-immutable';
+import { STATUS } from 'foremanReact/constants';
+import { deepPropsToCamelCase } from 'foremanReact/common/helpers';
+import {
+  selectAPIErrorMessage,
+  selectAPIStatus,
+  selectAPIResponse,
+} from 'foremanReact/redux/API/APISelectors';
+
+import { WEBHOOKS_API_REQUEST_KEY } from './constants';
+
+export const emptyResponse = {
+  results: [],
+  page: 0,
+  perPage: 0,
+  search: '',
+  sort: {},
+  canCreate: false,
+  subtotal: 0,
+  message: {},
+};
+
+const selectWebhooksPageResponse = state => {
+  const response = deepPropsToCamelCase(
+    selectAPIResponse(state, WEBHOOKS_API_REQUEST_KEY)
+  );
+  if (isEmpty(response)) {
+    return Immutable(emptyResponse);
+  }
+  return response;
+};
+
+export const selectIsLoading = state => {
+  const status = selectWebhooksPageStatus(state);
+  return !status || status === STATUS.PENDING;
+};
+
+const selectWebhooksPageStatus = state =>
+  selectAPIStatus(state, WEBHOOKS_API_REQUEST_KEY);
+
+export const selectHasError = state =>
+  selectWebhooksPageStatus(state) === STATUS.ERROR;
+
+export const selectWebhooks = state => {
+  if (selectHasError(state)) {
+    return [];
+  }
+  return selectWebhooksPageResponse(state).results;
+};
+
+export const selectHasData = state => {
+  const status = selectWebhooksPageStatus(state);
+  const results = selectWebhooks(state);
+
+  return status === STATUS.RESOLVED && results && results.length > 0;
+};
+
+export const selectPage = state => selectWebhooksPageResponse(state).page || 1;
+export const selectPerPage = state =>
+  selectWebhooksPageResponse(state).perPage || 20;
+export const selectSearch = state => selectWebhooksPageResponse(state).search;
+
+export const selectSort = state => {
+  const sort = selectWebhooksPageResponse(state).sort || Immutable({});
+  if (sort.by && sort.order) {
+    return { ...sort, by: camelCase(sort.by) };
+  }
+  return sort;
+};
+
+export const selectCanCreate = state =>
+  selectWebhooksPageResponse(state).canCreate || false;
+export const selectSubtotal = state =>
+  selectWebhooksPageResponse(state).subtotal || 0;
+export const selectMessage = state => {
+  if (selectHasError(state)) {
+    const message = {
+      type: 'error',
+      text: selectAPIErrorMessage(state, WEBHOOKS_API_REQUEST_KEY),
+    };
+    return message;
+  }
+  return selectWebhooksPageResponse(state).message;
+};

data/webpack/ForemanWebhooks/Routes/Webhooks/__tests__/WebhooksPageHelpers.test.js

@@ -0,0 +1,20 @@
+import { pickSort, buildQuery } from '../WebhooksPageHelpers';
+
+import {
+  querySort,
+  pickedQuery,
+  queryParams,
+  resultParams,
+} from '../WebhooksIndexPage/__tests__/WebhooksIndexPage.fixtures';
+
+describe('pickSort', () => {
+  it('should pick sort from query', () => {
+    expect(pickSort(querySort, {})).toStrictEqual(pickedQuery);
+  });
+});
+
+describe('buildQuery', () => {
+  it('should return params from query if present', () => {
+    expect(buildQuery(queryParams, {})).toStrictEqual(resultParams);
+  });
+});

data/webpack/ForemanWebhooks/Routes/Webhooks/__tests__/WebhooksPageSelectors.test.js

@@ -0,0 +1,45 @@
+import { testSelectorsSnapshotWithFixtures } from '@theforeman/test';
+
+import {
+  selectWebhooks,
+  selectPage,
+  selectPerPage,
+  selectSearch,
+  selectSort,
+  selectHasData,
+  selectHasError,
+  selectIsLoading,
+  selectSubtotal,
+  selectMessage,
+} from '../WebhooksPageSelectors';
+
+import {
+  stateFactory,
+  webhooks,
+} from '../WebhooksIndexPage/__tests__/WebhooksIndexPage.fixtures';
+
+const state = stateFactory({
+  results: webhooks,
+  sort: { by: 'name', order: 'DESC' },
+  page: 1,
+  perPage: 1,
+  search: 'name ~ foo',
+  subtotal: 42,
+  message: { type: 'error', text: 'This is error' },
+});
+
+const fixtures = {
+  'should return webhooks': () => selectWebhooks(state),
+  'should return page': () => selectPage(state),
+  'should return perPage': () => selectPerPage(state),
+  'should return search': () => selectSearch(state),
+  'should return sort': () => selectSort(state),
+  'should return hasData': () => selectHasData(state),
+  'should return hasError': () => selectHasError(state),
+  'should return isLoading': () => selectIsLoading(state),
+  'should return subtotal': () => selectSubtotal(state),
+  'should return message': () => selectMessage(state),
+};
+
+describe('WebhooksPage selectors', () =>
+  testSelectorsSnapshotWithFixtures(fixtures));

data/webpack/ForemanWebhooks/Routes/Webhooks/__tests__/__snapshots__/WebhooksPageSelectors.test.js.snap

@@ -0,0 +1,50 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`WebhooksPage selectors should return hasData 1`] = `false`;
+
+exports[`WebhooksPage selectors should return hasError 1`] = `false`;
+
+exports[`WebhooksPage selectors should return isLoading 1`] = `true`;
+
+exports[`WebhooksPage selectors should return message 1`] = `
+Object {
+  "text": "This is error",
+  "type": "error",
+}
+`;
+
+exports[`WebhooksPage selectors should return page 1`] = `1`;
+
+exports[`WebhooksPage selectors should return perPage 1`] = `1`;
+
+exports[`WebhooksPage selectors should return search 1`] = `"name ~ foo"`;
+
+exports[`WebhooksPage selectors should return sort 1`] = `
+Object {
+  "by": "name",
+  "order": "DESC",
+}
+`;
+
+exports[`WebhooksPage selectors should return subtotal 1`] = `42`;
+
+exports[`WebhooksPage selectors should return webhooks 1`] = `
+Array [
+  Object {
+    "canDelete": true,
+    "canEdit": true,
+    "enabled": true,
+    "id": 1,
+    "name": "my-webhook",
+    "targetUrl": "https://my-machine.example.com",
+  },
+  Object {
+    "canDelete": false,
+    "canEdit": false,
+    "enabled": false,
+    "id": 2,
+    "name": "your-webhook",
+    "targetUrl": "https://your-machine.example.com",
+  },
+]
+`;

data/webpack/ForemanWebhooks/Routes/Webhooks/constants.js

@@ -0,0 +1,13 @@
+import { getControllerSearchProps } from 'foremanReact/constants';
+
+export const WEBHOOKS_PAGE_DATA_RESOLVED = 'WEBHOOKS_PAGE_DATA_RESOLVED';
+export const WEBHOOKS_PAGE_DATA_FAILED = 'WEBHOOKS_PAGE_DATA_FAILED';
+export const WEBHOOKS_PAGE_HIDE_LOADING = 'WEBHOOKS_PAGE_HIDE_LOADING';
+export const WEBHOOKS_PAGE_SHOW_LOADING = 'WEBHOOKS_PAGE_SHOW_LOADING';
+export const WEBHOOKS_PAGE_CLEAR_ERROR = 'WEBHOOKS_PAGE_CLEAR_ERROR';
+
+export const WEBHOOKS_SEARCH_PROPS = getControllerSearchProps('webhooks');
+export const WEBHOOKS_API_PATH = '/api/v2/webhooks?include_permissions=true';
+export const WEBHOOKS_PATH = '/webhooks';
+export const WEBHOOK_DELETE_MODAL_ID = 'webhookDeleteModal';
+export const WEBHOOKS_API_REQUEST_KEY = 'WEBHOOKS';

data/webpack/__mocks__/foremanReact/common/HOC.js

@@ -0,0 +1,2 @@
+/* eslint no-empty-pattern: "off" */
+export const withRenderHandler = ({}) => componentProps => {};