foreman_ansible 6.4.1 → 7.0.0

data/webpack/graphql/mutations/updateAnsibleVariableOverride.gql

@@ -0,0 +1,29 @@
+mutation UpdateAnsibleVariableOverride(
+  $id: ID!,
+  $hostId: Int!,
+  $ansibleVariableId: Int!,
+  $value: RawJson!
+  $match: String!) {
+  updateAnsibleVariableOverride(input: { id: $id, hostId: $hostId, value: $value, ansibleVariableId: $ansibleVariableId }) {
+    overridenAnsibleVariable {
+      id
+      lookupValues(match: $match) {
+        nodes {
+          id
+          match
+          value
+          omit
+        }
+      }
+      currentValue {
+        element
+        value
+        elementName
+      }
+    }
+    errors {
+      path
+      message
+    }
+  }
+}

data/webpack/graphql/queries/allAnsibleRoles.gql

@@ -0,0 +1,13 @@
+query($id: String!, $first: Int, $last: Int){
+  host(id: $id) {
+    id
+    allAnsibleRoles(first: $first, last: $last) {
+      totalCount
+      nodes {
+        id
+        name
+        inherited
+      }
+    }
+  }
+}

data/webpack/graphql/queries/ansibleRoles.gql

@@ -0,0 +1,13 @@
+#import "./currentUserAttributes.gql"
+
+query($search: String) {
+  ansibleRoles(search: $search) {
+    nodes {
+      id
+      name
+    }
+  }
+  currentUser {
+    ...CurrentUserAttributes
+  }
+}

data/webpack/graphql/queries/currentUserAttributes.gql

@@ -0,0 +1,11 @@
+fragment CurrentUserAttributes on User {
+  id
+  login
+  admin
+  permissions {
+    nodes {
+      id
+      name
+    }
+  }
+}

data/webpack/graphql/queries/hostAnsibleRoles.gql

@@ -0,0 +1,17 @@
+#import "./currentUserAttributes.gql"
+
+query($id: String!, $first: Int, $last: Int) {
+  host(id: $id) {
+    id
+    ownAnsibleRoles(first: $first, last: $last) {
+      totalCount
+      nodes {
+        id
+        name
+      }
+    }
+  }
+  currentUser {
+    ...CurrentUserAttributes
+  }
+}

data/webpack/graphql/queries/hostAvailableAnsibleRoles.gql

@@ -0,0 +1,11 @@
+query($id: String!) {
+  host(id: $id) {
+    id
+    availableAnsibleRoles {
+      nodes {
+        id
+        name
+      }
+    }
+  }
+}

data/webpack/graphql/queries/hostVariableOverrides.gql

@@ -0,0 +1,39 @@
+#import "./currentUserAttributes.gql"
+
+query($id: String!, $match: String, $first: Int, $last: Int) {
+  host(id: $id) {
+    id
+    ansibleVariablesWithOverrides(first: $first, last: $last) {
+      totalCount
+      nodes {
+        id
+        key
+        meta {
+          canEdit
+        }
+        defaultValue
+        parameterType
+        ansibleRoleName
+        validatorType
+        validatorRule
+        required
+        lookupValues(match: $match) {
+          nodes {
+            id
+            match
+            value
+            omit
+          }
+        }
+        currentValue {
+          value
+          element
+          elementName
+        }
+      }
+    }
+  }
+  currentUser {
+    ...CurrentUserAttributes
+  }
+}

data/webpack/graphql/queries/recurringJobs.gql

@@ -0,0 +1,28 @@
+#import "./currentUserAttributes.gql"
+
+query($search: String, $first: Int, $last: Int) {
+  jobInvocations(search: $search, first: $first, last: $last) {
+    totalCount
+    nodes {
+      id
+      description
+      startAt
+      statusLabel
+      recurringLogic {
+        id
+        cronLine
+        meta {
+          canEdit
+        }
+      }
+      task {
+        id
+        state
+        result
+      }
+    }
+  }
+  currentUser {
+    ...CurrentUserAttributes
+  }
+}

data/webpack/helpers/pageParamsHelper.js

@@ -0,0 +1,40 @@
+import URI from 'urijs';
+import { useForemanSettings } from 'foremanReact/Root/Context/ForemanContext';
+
+const parsePageParams = history => URI.parseQuery(history.location.search);
+
+export const addSearch = (basePath, params) => {
+  let stringyfied = '';
+  if (Object.keys(params).length > 0) {
+    stringyfied = `?${URI.buildQuery(params)}`;
+  }
+
+  return `${basePath}${stringyfied}`;
+};
+
+export const useCurrentPagination = (
+  history,
+  keys = { page: 'page', perPage: 'perPage' }
+) => {
+  const pageParams = parsePageParams(history);
+  const uiSettings = useForemanSettings();
+
+  return {
+    [keys.page]: parseInt(pageParams[keys.page], 10) || 1,
+    [keys.perPage]:
+      parseInt(pageParams[keys.perPage], 10) || uiSettings.perPage,
+  };
+};
+
+export const pageToVars = (
+  pagination,
+  keys = { page: 'page', perPage: 'perPage' }
+) => ({
+  first: pagination[keys.page] * pagination[keys.perPage],
+  last: pagination[keys.perPage],
+});
+
+export const useParamsToVars = (
+  history,
+  keys = { page: 'page', perPage: 'perPage' }
+) => pageToVars(useCurrentPagination(history, keys), keys);

data/webpack/helpers/paginationHelper.js

@@ -0,0 +1,9 @@
+import { addSearch } from './pageParamsHelper';
+
+export const preparePerPageOptions = opts =>
+  opts.map(item => ({ title: item.toString(), value: item }));
+
+export const refreshPage = (history, params = {}) => {
+  const url = addSearch(history.location.pathname, params);
+  history.push(url);
+};

data/webpack/permissionsHelper.js

@@ -0,0 +1,58 @@
+import { translate as __, sprintf } from 'foremanReact/common/I18n';
+
+export const permissionCheck = (user, permissionsRequired) => {
+  if (permissionsRequired.length === 0) {
+    return { allowed: true };
+  }
+
+  if (!user) {
+    throw new Error(
+      'No user data when loading the page - cannot determine if current user is allowed to view the page.'
+    );
+  }
+
+  if (user.admin) {
+    return { allowed: true };
+  }
+
+  const permList = permissionsRequired.reduce((memo, item) => {
+    const found = user.permissions.nodes.find(
+      permission => permission.name === item
+    );
+    memo.push({ name: item, present: !!found });
+    return memo;
+  }, []);
+
+  if (permList.reduce((memo, item) => memo && item.present, true)) {
+    return { allowed: true, permissions: permList };
+  }
+
+  return { allowed: false, permissions: permList };
+};
+
+export const permissionDeniedMsg = permissions => {
+  let msg = __('You are not authorized to view the page. ');
+  if (permissions?.length > 0) {
+    msg += sprintf(
+      __('Request the following permissions from administrator: %s.'),
+      permissions.join(', ')
+    );
+  }
+  return msg;
+};
+
+export const allowPrimaryAction = (
+  emptyStateProps,
+  currentUser,
+  permissionsRequired
+) => {
+  if (!permissionCheck(currentUser, permissionsRequired).allowed) {
+    return Object.keys(emptyStateProps)
+      .filter(key => key !== 'action')
+      .reduce((memo, key) => {
+        memo[key] = emptyStateProps[key];
+        return memo;
+      }, {});
+  }
+  return emptyStateProps;
+};

data/webpack/routes/HostgroupJobs/__test__/HostgroupJobs.fixtures.js

@@ -0,0 +1,63 @@
+import { toVars } from '../../../components/AnsibleHostDetail/components/JobsTab/NewRecurringJobHelper';
+
+import {
+  scheduledJobsSearch,
+  previousJobsSearch,
+} from '../../../components/AnsibleHostDetail/components/JobsTab/JobsTabHelper';
+import {
+  jobInvocationsMockFactory,
+  jobCreateMockFactory,
+  firstJob,
+  secondJob,
+  futureDate,
+} from '../../../components/AnsibleHostDetail/components/JobsTab/__test__/JobsTab.fixtures';
+
+import { admin } from '../../../testHelper';
+
+export const hgId = 22;
+export const matchMock = {
+  params: {
+    id: '22',
+  },
+};
+export { futureDate };
+
+const emptyScheduledJobsMock = jobInvocationsMockFactory(
+  { search: scheduledJobsSearch('hostgroup', hgId) },
+  { nodes: [], totalCount: 0 },
+  { currentUser: admin }
+);
+const emptyScheduledJobsRefetchMock = jobInvocationsMockFactory(
+  { search: scheduledJobsSearch('hostgroup', hgId) },
+  { nodes: [], totalCount: 0 },
+  { refetchData: { nodes: [firstJob], totalCount: 1 }, currentUser: admin }
+);
+const emptyPreviousJobsMock = jobInvocationsMockFactory(
+  { search: previousJobsSearch('hostgroup', hgId), first: 20, last: 20 },
+  { nodes: [], totalCount: 0 },
+  { currentUser: admin }
+);
+const scheduledJobsMocks = jobInvocationsMockFactory(
+  { search: scheduledJobsSearch('hostgroup', hgId) },
+  { nodes: [firstJob], totalCount: 1 },
+  { currentUser: admin }
+);
+const previousJobsMocks = jobInvocationsMockFactory(
+  { search: previousJobsSearch('hostgroup', hgId), first: 20, last: 20 },
+  { nodes: [secondJob], totalCount: 1 },
+  { currentUser: admin }
+);
+
+export const emptyMocks = emptyScheduledJobsMock.concat(emptyPreviousJobsMock);
+export const scheduledAndPreviousMocks = scheduledJobsMocks.concat(
+  previousJobsMocks
+);
+
+const createJobMock = jobCreateMockFactory(
+  toVars('hostgroup', hgId, futureDate, 'weekly').variables,
+  { jobInvocation: { id: 'MDE6Sm9iSW52b2NhdGlvbi00MTU=' }, errors: [] }
+);
+
+export const createMocks = emptyScheduledJobsRefetchMock
+  .concat(emptyPreviousJobsMock)
+  .concat(createJobMock);

data/webpack/routes/HostgroupJobs/__test__/HostgroupJobs.test.js

@@ -0,0 +1,112 @@
+import React from 'react';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import '@testing-library/jest-dom';
+
+import { i18nProviderWrapperFactory } from 'foremanReact/common/i18nProviderWrapperFactory';
+
+import {
+  emptyMocks,
+  scheduledAndPreviousMocks,
+  createMocks,
+  matchMock,
+  futureDate,
+} from './HostgroupJobs.fixtures';
+import HostgroupJobs from '../';
+import * as toasts from '../../../toastHelper';
+
+import {
+  tick,
+  withRouter,
+  withMockedProvider,
+  withRedux,
+  historyMock,
+} from '../../../testHelper';
+
+import { toCron } from '../../../components/AnsibleHostDetail/components/JobsTab/NewRecurringJobHelper';
+
+const TestComponent = withRedux(withRouter(withMockedProvider(HostgroupJobs)));
+
+const now = new Date('2021-08-28 00:00:00 -1100');
+const ComponentWithIntl = i18nProviderWrapperFactory(now, 'UTC')(TestComponent);
+
+describe('HostgroupJobs', () => {
+  it('should load the page', async () => {
+    render(
+      <ComponentWithIntl
+        match={matchMock}
+        mocks={scheduledAndPreviousMocks}
+        history={historyMock}
+      />
+    );
+    await waitFor(tick);
+    await waitFor(tick);
+    screen
+      .getAllByText('Run Ansible roles')
+      .map(element => expect(element).toBeInTheDocument());
+    expect(screen.getByText('Scheduled recurring jobs')).toBeInTheDocument();
+    expect(screen.getByText('Previously executed jobs')).toBeInTheDocument();
+    expect(screen.getByText('54 10 15 * *')).toBeInTheDocument();
+  });
+  it('should show empty state', async () => {
+    render(
+      <ComponentWithIntl
+        match={matchMock}
+        mocks={emptyMocks}
+        history={historyMock}
+      />
+    );
+    await waitFor(tick);
+    await waitFor(tick);
+    expect(
+      screen.getByText('No config job for Ansible roles scheduled')
+    ).toBeInTheDocument();
+  });
+  it('should create new recurring job', async () => {
+    const showToast = jest.fn();
+    jest.spyOn(toasts, 'showToast').mockImplementation(showToast);
+
+    render(
+      <ComponentWithIntl
+        match={matchMock}
+        mocks={createMocks}
+        history={historyMock}
+      />
+    );
+    await waitFor(tick);
+    userEvent.click(
+      screen.getByRole('button', { name: 'schedule recurring job' })
+    );
+    await waitFor(tick);
+    userEvent.selectOptions(screen.getByLabelText(/repeat/), 'weekly');
+    userEvent.type(
+      screen.getByLabelText(/startTime/),
+      futureDate
+        .toISOString()
+        .split('T')[1]
+        .slice(0, 5)
+    );
+    userEvent.type(
+      screen.getByLabelText(/startDate/),
+      futureDate.toISOString().split('T')[0]
+    );
+    expect(
+      screen.getByRole('button', { name: 'submit creating job' })
+    ).not.toBeDisabled();
+    userEvent.click(
+      screen.getByRole('button', { name: 'submit creating job' })
+    );
+    await waitFor(tick);
+    await waitFor(tick);
+    await waitFor(tick);
+    expect(showToast).toHaveBeenCalledWith({
+      type: 'success',
+      message: 'Ansible job was successfully created.',
+    });
+    expect(screen.getByText(toCron(futureDate, 'weekly'))).toBeInTheDocument();
+    expect(screen.getByText('in 3 days')).toBeInTheDocument();
+    expect(
+      screen.queryByText('No config job for Ansible roles scheduled')
+    ).not.toBeInTheDocument();
+  });
+});

data/webpack/routes/HostgroupJobs/index.js

@@ -0,0 +1,26 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Helmet } from 'react-helmet';
+import { translate as __ } from 'foremanReact/common/I18n';
+
+import JobsPage from '../../components/AnsibleHostDetail/components/JobsTab';
+
+const HostgroupJobs = props => (
+  <React.Fragment>
+    <Helmet>
+      <title>{__('Configure Recurring Job')}</title>
+    </Helmet>
+    <JobsPage
+      resourceName="hostgroup"
+      resourceId={parseInt(props.match.params.id, 10)}
+      history={props.history}
+    />
+  </React.Fragment>
+);
+
+HostgroupJobs.propTypes = {
+  match: PropTypes.object.isRequired,
+  history: PropTypes.object.isRequired,
+};
+
+export default HostgroupJobs;

data/webpack/routes/routes.js

@@ -0,0 +1,10 @@
+import React from 'react';
+import HostgroupJobs from './HostgroupJobs';
+
+export default [
+  {
+    path: '/ansible/hostgroups/:id',
+    render: props => <HostgroupJobs {...props} />,
+    exact: true,
+  },
+];

data/webpack/testHelper.js

@@ -0,0 +1,165 @@
+import React from 'react';
+import { Provider } from 'react-redux';
+import { MockedProvider } from '@apollo/react-testing';
+import { Router, MemoryRouter } from 'react-router-dom';
+import { createMemoryHistory } from 'history';
+
+import store from 'foremanReact/redux';
+import ConfirmModal from 'foremanReact/components/ConfirmModal';
+import { getForemanContext } from 'foremanReact/Root/Context/ForemanContext';
+
+export const withRedux = Component => props => (
+  <Provider store={store}>
+    <Component {...props} />
+    <ConfirmModal />
+  </Provider>
+);
+
+export const withRouter = Component => props => (
+  <MemoryRouter>
+    <Component {...props} />
+  </MemoryRouter>
+);
+
+export const withReactRouter = Component => props => {
+  // eslint-disable-next-line react/prop-types
+  const history = props.history || createMemoryHistory();
+
+  return (
+    <Router history={history}>
+      <Component {...props} history={history} />
+    </Router>
+  );
+};
+
+export const withMockedProvider = Component => props => {
+  const ForemanContext = getForemanContext(ctx);
+  // eslint-disable-next-line react/prop-types
+  const { mocks, ...rest } = props;
+
+  const ctx = {
+    metadata: {
+      UISettings: {
+        perPage: 20,
+      },
+    },
+  };
+
+  return (
+    <ForemanContext.Provider value={ctx}>
+      <MockedProvider mocks={mocks}>
+        <Component {...rest} />
+      </MockedProvider>
+    </ForemanContext.Provider>
+  );
+};
+
+export const userFactory = (login, permissions = []) => ({
+  __typename: 'User',
+  id: 'MDE6VXNlci01',
+  login,
+  admin: false,
+  permissions: {
+    nodes: permissions,
+  },
+});
+
+export const admin = {
+  __typename: 'User',
+  id: 'MDE6VXNlci00',
+  login: 'admin',
+  admin: true,
+  permissions: {
+    nodes: [],
+  },
+};
+
+export const intruder = userFactory('intruder', [
+  {
+    __typename: 'Permission',
+    id: 'MDE6UGVybWlzc2lvbi0x',
+    name: 'view_architectures',
+  },
+]);
+
+// use to resolve async mock requests for apollo MockedProvider
+export const tick = () => new Promise(resolve => setTimeout(resolve, 0));
+
+export const historyMock = {
+  location: {
+    search: '',
+  },
+};
+
+export const mockFactory = (resultName, query) => (
+  variables,
+  modelResults,
+  { errors = [], currentUser = null, refetchData = null } = {}
+) => {
+  let called = false;
+
+  const returnData = results => {
+    const result = {
+      data: {
+        [resultName]: results,
+      },
+    };
+
+    if (errors.length !== 0) {
+      result.errors = errors;
+    }
+
+    if (currentUser) {
+      result.data.currentUser = currentUser;
+    }
+
+    return result;
+  };
+
+  const mock = {
+    request: {
+      query,
+      variables,
+    },
+    newData: () => {
+      if (called && refetchData) {
+        return returnData(refetchData);
+      }
+      called = true;
+      return returnData(modelResults);
+    },
+  };
+
+  return [mock];
+};
+
+export const advancedMockFactory = query => (
+  variables,
+  data,
+  { errors = [], currentUser = null, refetchData = null } = {}
+) => {
+  let called = false;
+
+  const mock = {
+    request: {
+      query,
+      variables,
+    },
+    newData: () => {
+      if (called && refetchData) {
+        return { data: refetchData };
+      }
+      called = true;
+      return { data };
+    },
+  };
+
+  if (errors.length !== 0) {
+    mock.result.errors = errors;
+  }
+
+  if (currentUser) {
+    mock.result.data.currentUser = currentUser;
+  }
+  return [mock];
+};

data/webpack/toastHelper.js

@@ -0,0 +1,4 @@
+import store from 'foremanReact/redux';
+import { addToast } from 'foremanReact/components/ToastsList';
+
+export const showToast = toast => store.dispatch(addToast(toast));