foreman-tasks 0.16.0 → 0.16.1

data/webpack/ForemanTasks/Components/TaskDetails/Components/TaskHelper.js

@@ -0,0 +1,38 @@
+import { translate as __, documentLocale } from 'foremanReact/common/I18n';
+import React from 'react';
+import { FormattedRelative } from 'react-intl';
+import humanizeDuration from 'humanize-duration';
+
+const formatDate = date => {
+  // Firefox doesnt format dd-mm-yyyy type strings to date
+  if (typeof date === 'string' || date instanceof String)
+    return new Date(date.replace(/-/, '/').replace(/-/, '/'));
+  return date;
+};
+
+export const timeInWords = time => {
+  if (!time) return __('N/A');
+  time = formatDate(time);
+  return <FormattedRelative value={time} />;
+};
+
+export const durationInWords = (
+  start,
+  finish,
+  selectedLocale = documentLocale()
+) => {
+  if (!start) return __('N/A');
+  start = formatDate(start).getTime();
+  finish = formatDate(finish).getTime();
+  return {
+    text: humanizeDuration(new Date(finish - start).getTime(), {
+      largest: 1,
+      language: selectedLocale,
+      fallbacks: ['en'],
+    }),
+    tooltip: `${numberWithDelimiter((finish - start) / 1000)} ${__('seconds')}`,
+  };
+};
+
+const numberWithDelimiter = x =>
+  x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');

data/webpack/ForemanTasks/Components/TaskDetails/Components/TaskInfo.js

@@ -0,0 +1,238 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import { Grid, Row, Col, ProgressBar } from 'patternfly-react';
+import { translate as __ } from 'foremanReact/common/I18n';
+import EllipsisWithTooltip from 'react-ellipsis-with-tooltip';
+import { timeInWords } from './TaskHelper';
+
+class TaskInfo extends Component {
+  isDelayed = () => {
+    const startAt = new Date(this.props.startAt);
+    const startedAt = new Date(this.props.startedAt);
+    startAt.setMilliseconds(0);
+    startedAt.setMilliseconds(0);
+    return startAt.getTime() !== startedAt.getTime();
+  };
+  resultIcon = () => {
+    if (this.props.state !== 'stopped') return 'task-status pficon-help';
+    const { result } = this.props;
+    let icon;
+    switch (result) {
+      case 'success':
+        icon = 'pficon-ok';
+        break;
+      case 'error':
+        icon = 'pficon-error-circle-o';
+        break;
+      case 'warning':
+        icon = 'pficon-ok status-warn';
+        break;
+      default:
+        icon = 'pficon-help';
+        break;
+    }
+    return `task-status ${icon}`;
+  };
+
+  progressBarType = () => {
+    const { result } = this.props;
+    switch (result) {
+      case 'error':
+        return 'danger';
+      case 'success':
+        return 'success';
+      case 'warning':
+        return 'warning';
+      default:
+        return null;
+    }
+  };
+
+  render() {
+    const {
+      action,
+      endedAt,
+      result,
+      startAt,
+      startBefore,
+      startedAt,
+      state,
+      help,
+      output,
+      error,
+      progress,
+      username,
+      usernamePath,
+    } = this.props;
+
+    const details = [
+      [
+        {
+          title: 'Name',
+          value: (
+            <EllipsisWithTooltip>{action || __('N/A')}</EllipsisWithTooltip>
+          ),
+        },
+        { title: 'Start at', value: timeInWords(startAt) },
+      ],
+      [
+        {
+          title: 'Result',
+          value: (
+            <React.Fragment>
+              <i className={this.resultIcon()} />
+              <span> {result}</span>
+            </React.Fragment>
+          ),
+        },
+        { title: 'Started at', value: timeInWords(startedAt) },
+      ],
+      [
+        {
+          title: 'Triggered by',
+          value: (usernamePath || '').includes('href') ? (
+            <a href={usernamePath.split('"')[1]}>{username}</a>
+          ) : (
+            username || ''
+          ),
+        },
+        { title: 'Ended at', value: timeInWords(endedAt) },
+      ],
+      [
+        {
+          title: 'Execution type',
+          value: __(this.isDelayed() ? 'Delayed' : 'Immediate'),
+        },
+        {
+          title: 'Start before',
+          value: startBefore ? timeInWords(startBefore) : '-',
+        },
+      ],
+    ];
+    return (
+      <Grid>
+        <br />
+        {details.map((items, key) => (
+          <Row key={key}>
+            <Col md={2} sm={6}>
+              <span className="list-group-item-heading">
+                {__(items[0].title)}:
+              </span>
+            </Col>
+            <Col md={5} sm={6}>
+              <span>{items[0].value}</span>
+            </Col>
+            <Col md={2} sm={6}>
+              <span className="list-group-item-heading">
+                {__(items[1].title)}:
+              </span>
+            </Col>
+            <Col md={3} sm={6}>
+              {items[1].value}
+            </Col>
+          </Row>
+        ))}
+        <br />
+        <Row>
+          <Col xs={6}>
+            <div className="progress-description">
+              <span className="list-group-item-heading">{__('State')}: </span>
+              {state}
+            </div>
+          </Col>
+          <Col xs={3} xsOffset={3} className="progress-label-top-right">
+            <span>{`${progress}% ${__('Complete')}`}</span>
+          </Col>
+          <Col xs={12}>
+            <ProgressBar
+              now={progress}
+              bsStyle={this.progressBarType()}
+              striped
+            />
+          </Col>
+        </Row>
+        <br />
+        {help && (
+          <Row>
+            <Col xs={12}>
+              <p>
+                <span>
+                  <b>{__('Troubleshooting')}</b>
+                </span>
+              </p>
+              <p>
+                {help.split('\n').map((item, i) => (
+                  <React.Fragment key={i}>
+                    {item}
+                    <br />
+                  </React.Fragment>
+                ))}
+              </p>
+            </Col>
+          </Row>
+        )}
+        {output && output.length > 0 && (
+          <Row>
+            <Col xs={12}>
+              <p>
+                <span>
+                  <b>{__('Output:')}</b>
+                </span>
+              </p>
+              <pre>{output}</pre>
+            </Col>
+          </Row>
+        )}
+        {error && error.length > 0 && (
+          <Row>
+            <Col xs={12}>
+              <div>
+                <span>
+                  <b>{__('Errors:')}</b>
+                </span>
+              </div>
+              <pre>{error}</pre>
+            </Col>
+          </Row>
+        )}
+      </Grid>
+    );
+  }
+}
+
+TaskInfo.propTypes = {
+  action: PropTypes.string,
+  endedAt: PropTypes.string,
+  result: PropTypes.string,
+  startAt: PropTypes.string,
+  startBefore: PropTypes.string,
+  startedAt: PropTypes.string,
+  state: PropTypes.string,
+  help: PropTypes.string,
+  error: PropTypes.array,
+  progress: PropTypes.number,
+  username: PropTypes.string,
+  usernamePath: PropTypes.string,
+  output: PropTypes.PropTypes.oneOfType([
+    PropTypes.string,
+    PropTypes.shape({}),
+  ]),
+};
+
+TaskInfo.defaultProps = {
+  action: '',
+  endedAt: '',
+  result: 'error',
+  startAt: '',
+  startBefore: '',
+  startedAt: '',
+  state: '',
+  help: '',
+  error: [],
+  progress: 0,
+  username: '',
+  usernamePath: '',
+  output: '',
+};
+
+export default TaskInfo;

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/Errors.test.js

@@ -0,0 +1,36 @@
+import { testComponentSnapshotsWithFixtures } from 'react-redux-test-utils';
+
+import Errors from '../Errors';
+
+const fixtures = {
+  'render without Props': {},
+  'render with Props': {
+    executionPlan: {
+      state: 'paused',
+      cancellable: false,
+    },
+    failedSteps: [
+      {
+        error: {
+          exception_class: 'RuntimeError',
+          message:
+            'Action Actions::Katello::EventQueue::Monitor is already active',
+          backtrace: [
+            "/home/vagrant/.gem/ruby/gems/dynflow-1.2.3/lib/dynflow/action/singleton.rb:15:in `rescue in singleton_lock!'",
+            "/home/vagrant/.gem/ruby/gems/dynflow-1.2.3/lib/dynflow/action/singleton.rb:12:in `singleton_lock!'",
+          ],
+        },
+        action_class: 'Actions::Katello::EventQueue::Monitor',
+        state: 'error',
+        input:
+          '{"locale"=>"en",\n "current_request_id"=>nil,\n "current_user_id"=>4,\n "current_organization_id"=>nil,\n "current_location_id"=>nil}\n',
+        output: '{}\n',
+      },
+    ],
+  },
+};
+
+describe('Errors', () => {
+  describe('rendering', () =>
+    testComponentSnapshotsWithFixtures(Errors, fixtures));
+});

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/Locks.test.js

@@ -0,0 +1,28 @@
+import { testComponentSnapshotsWithFixtures } from 'react-redux-test-utils';
+
+import Locks from '../Locks';
+
+const fixtures = {
+  'render without Props': {},
+  'render with Props': {
+    locks: [
+      {
+        name: 'task_owner',
+        exclusive: false,
+        resource_type: 'User',
+        resource_id: 4,
+      },
+      {
+        name: 'task_owner2',
+        exclusive: false,
+        resource_type: 'User',
+        resource_id: 2,
+      },
+    ],
+  },
+};
+
+describe('Locks', () => {
+  describe('rendering', () =>
+    testComponentSnapshotsWithFixtures(Locks, fixtures));
+});

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/Raw.test.js

@@ -0,0 +1,27 @@
+import { testComponentSnapshotsWithFixtures } from 'react-redux-test-utils';
+
+import Raw from '../Raw';
+
+const fixtures = {
+  'render without Props': {},
+  'render with Props': {
+    startedAt: '2019-06-17 16:04:09 +0300',
+    endedAt: '2019-06-17 16:05:09 +0300',
+    id: '6b0d6db2-e9ab-40da-94e5-b6842ac50bd0',
+    label: 'Actions::Katello::EventQueue::Monitor',
+    input: {
+      locale: 'en',
+      current_request_id: 1,
+      current_user_id: 4,
+      current_organization_id: 2,
+      current_location_id: 3,
+    },
+    output: {},
+    externalId: 'test',
+  },
+};
+
+describe('Raw', () => {
+  describe('rendering', () =>
+    testComponentSnapshotsWithFixtures(Raw, fixtures));
+});

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/RunningSteps.test.js

@@ -0,0 +1,29 @@
+import { testComponentSnapshotsWithFixtures } from 'react-redux-test-utils';
+
+import RunningSteps from '../RunningSteps';
+
+const fixtures = {
+  'render without Props': {},
+  'render with Props': {
+    executionPlan: {
+      state: 'paused',
+      cancellable: false,
+    },
+    runningSteps: [
+      {
+        cancellable: false,
+        id: 1,
+        action_class: 'test',
+        state: 'paused',
+        input:
+          '{"locale"=>"en",\n "current_request_id"=>nil,\n "current_user_id"=>4,\n "current_organization_id"=>nil,\n "current_location_id"=>nil}\n',
+        output: '{}\n',
+      },
+    ],
+  },
+};
+
+describe('RunningSteps', () => {
+  describe('rendering', () =>
+    testComponentSnapshotsWithFixtures(RunningSteps, fixtures));
+});

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/Task.test.js

@@ -0,0 +1,18 @@
+import { testComponentSnapshotsWithFixtures } from 'react-redux-test-utils';
+
+import Task from '../Task';
+
+const fixtures = {
+  'render without Props': { id: 'test' },
+  'render with some Props': {
+    id: 'test',
+    state: 'paused',
+    hasSubTasks: true,
+    allowDangerousActions: true,
+  },
+};
+
+describe('Task', () => {
+  describe('rendering', () =>
+    testComponentSnapshotsWithFixtures(Task, fixtures));
+});

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/TaskHelper.test.js

@@ -0,0 +1,77 @@
+import React from 'react';
+import { mount } from 'enzyme';
+import toJson from 'enzyme-to-json';
+import { IntlProvider } from 'react-intl';
+import { timeInWords, durationInWords } from '../TaskHelper';
+
+describe('timeInWords', () => {
+  it('should work for past minutes', () => {
+    const component = mount(
+      <IntlProvider locale="en">
+        {timeInWords(new Date().getTime() - 1000 * 60 * 5)}
+      </IntlProvider>
+    );
+    expect(toJson(component.render())).toMatchSnapshot();
+  });
+  it('should work for past hours', () => {
+    const component = mount(
+      <IntlProvider locale="en">
+        {timeInWords(new Date().getTime() - 1000 * 60 * 60 * 5)}
+      </IntlProvider>
+    );
+    expect(toJson(component.render())).toMatchSnapshot();
+  });
+  it('should work for past days', () => {
+    const component = mount(
+      <IntlProvider locale="en">
+        {timeInWords(new Date().getTime() - 1000 * 60 * 60 * 24 * 5)}
+      </IntlProvider>
+    );
+    expect(toJson(component.render())).toMatchSnapshot();
+  });
+  it('should work for future minutes', () => {
+    const component = mount(
+      <IntlProvider locale="en">
+        {timeInWords(new Date().getTime() + 1000 * 60 * 5)}
+      </IntlProvider>
+    );
+    expect(toJson(component.render())).toMatchSnapshot();
+  });
+  it('should work for future hours', () => {
+    const component = mount(
+      <IntlProvider locale="en">
+        {timeInWords(new Date().getTime() + 1000 * 60 * 60 * 5)}
+      </IntlProvider>
+    );
+    expect(toJson(component.render())).toMatchSnapshot();
+  });
+  it('should work for future days', () => {
+    const component = mount(
+      <IntlProvider locale="en">
+        {timeInWords(new Date().getTime() + 1000 * 60 * 60 * 24 * 5)}
+      </IntlProvider>
+    );
+    expect(toJson(component.render())).toMatchSnapshot();
+  });
+});
+
+describe('durationInWords', () => {
+  it('should work for seconds', () => {
+    expect(durationInWords('1/1/1 10:00:00', '1/1/1 10:00:01')).toEqual({
+      text: '1 second',
+      tooltip: '1 seconds',
+    });
+  });
+  it('should work for minutes', () => {
+    expect(durationInWords('1/1/1 10:00:00', '1/1/1 10:02:01')).toEqual({
+      text: '2 minutes',
+      tooltip: '121 seconds',
+    });
+  });
+  it('should work for hours', () => {
+    expect(durationInWords('1/1/1 10:00:00', '1/1/1 13:00:01')).toEqual({
+      text: '3 hours',
+      tooltip: '10,801 seconds',
+    });
+  });
+});