foreman_leapp 0.0.5 → 0.1.3

data/test/functional/preupgrade_reports_controller_test.rb

@@ -4,13 +4,36 @@ require 'test_plugin_helper'
 
 class PreupgradeReportsControllerTest < ActionController::TestCase
   setup do
+    @user = FactoryBot.create(:user, admin: false)
     @host = FactoryBot.create :host
     FactoryBot.create :preupgrade_report, host: @host
   end
 
-  test 'should get index' do
-    get :index, session: set_session_user
-    response = ActiveSupport::JSON.decode(@response.body)
-    assert_equal @host.id, response['results'].first['host_id']
+  test 'should get :index' do
+    get :index
+    assert_response :success
+    assert_not_empty JSON.parse(@response.body)['results']
+  end
+
+  test 'should get :index with :view_job_invocations & :view_hosts' do
+    setup_user 'view', 'job_invocations', nil, @user
+    setup_user 'view', 'hosts', nil, @user
+    get :index, session: set_session_user(@user)
+    assert_response :success
+    assert_not_empty JSON.parse(@response.body)['results']
+  end
+
+  test 'should not get :index without :view_job_invocations' do
+    setup_user 'view', 'hosts', nil, @user
+    get :index, session: set_session_user(@user)
+    assert_response :forbidden
+    assert_includes JSON.parse(@response.body)['error']['missing_permissions'], 'view_job_invocations'
+  end
+
+  test 'should not get :index without :view_hosts' do
+    setup_user 'view', 'job_invocations', nil, @user
+    get :index, session: set_session_user(@user)
+    assert_response :forbidden
+    assert_includes JSON.parse(@response.body)['error']['missing_permissions'], 'view_hosts'
   end
 end

data/test/unit/actions/preupgrade_job_test.rb

@@ -11,7 +11,7 @@ module ForemanLeapp
       FactoryBot.create(:job_template, template: 'echo "1"', job_category: 'leapp',
                                        provider_type: 'SSH', name: 'Leapp preupgrade')
     end
-    let(:job_invocation) { FactoryBot.create(:job_invocation, job_category: ::ForemanLeapp::JOB_CATEGORY) }
+    let(:job_invocation) { FactoryBot.create(:job_invocation) }
     let(:template_invocation) do
       FactoryBot.create(:template_invocation, template: job_template, job_invocation: job_invocation)
     end

data/test/unit/helpers/job_helper_test.rb

@@ -5,12 +5,12 @@ require 'test_plugin_helper'
 module Helpers
   class JobHelperTest < ActionView::TestCase
     let(:helper) { ::Helpers::JobHelper }
-    # let(:host) { FactoryBot.create(:host) }
+
     let(:job_template) do
       FactoryBot.create(:job_template, template: 'echo "1"', job_category: 'leapp',
                                        provider_type: 'SSH', name: 'Leapp preupgrade')
     end
-    let(:job_invocation) { FactoryBot.create(:job_invocation, job_category: ::ForemanLeapp::JOB_CATEGORY) }
+    let(:job_invocation) { FactoryBot.create(:job_invocation) }
 
     describe 'correct_feature?' do
       setup do
@@ -18,17 +18,10 @@ module Helpers
         FactoryBot.create(:template_invocation, template: job_template, job_invocation: job_invocation)
       end
 
-      it 'correct category & feature' do
+      it 'correct feature' do
         assert helper.correct_feature?(job_invocation, 'leapp_preupgrade')
       end
 
-      it 'wrong category' do
-        job_invocation = FactoryBot.create(:job_invocation, job_category: 'NOPE')
-        FactoryBot.create(:template_invocation, template: job_template, job_invocation: job_invocation)
-
-        assert_not helper.correct_feature?(job_invocation, 'leapp_preupgrade')
-      end
-
       it 'wrong feature' do
         assert_not helper.correct_feature?(job_invocation, 'leapp_preupgrade2')
       end

data/webpack/__mocks__/foremanReact/Root/Context/ForemanContext.js

@@ -0,0 +1,4 @@
+export const useForemanSettings = () => ({
+  perPage: 20,
+  perPageOptions: [5, 10, 20, 30, 50],
+});

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

@@ -1 +1 @@
-export const translate = () => jest.fn();
+export const translate = val => val;

data/webpack/__mocks__/foremanReact/components/Pagination/PaginationWrapper.js

@@ -0,0 +1,2 @@
+const PaginationWrapper = () => jest.fn();
+export default PaginationWrapper;

data/webpack/__mocks__/foremanReact/components/common/EmptyState.js

@@ -0,0 +1 @@
+export const EmptyStatePattern = () => jest.fn();

data/webpack/components/PreupgradeReports/PreupgradeReports.js

@@ -1,12 +1,119 @@
-import React from 'react';
+import React, { useState } from 'react';
 import MessageBox from 'foremanReact/components/common/MessageBox';
-import { LoadingState } from 'patternfly-react';
+import { LoadingState, Row } from 'patternfly-react';
 import PropTypes from 'prop-types';
 
 import PreupgradeReportsList from '../PreupgradeReportsList';
+import UpgradeAllButton from './components/UpgradeAllButton';
+import EntriesFilter from './components/EntriesFilter';
+import FixSelectedButton from './components/FixSelectedButton';
 
-const PreupgradeReports = ({ preupgradeReports, loading, error }) => {
-  if (Object.keys(error).length > 0) {
+import {
+  flattenEntries,
+  isEmpty,
+  anyEntriesFixable,
+  filterEntries,
+  idsForInvocationFromEntries,
+  sortEntries,
+  fixableEntries,
+} from './PreupgradeReportsHelpers';
+
+import NoReports from './components/NoReports';
+
+const PreupgradeReports = ({
+  preupgradeReports,
+  csrfToken,
+  newJobInvocationUrl,
+}) => {
+  const [filterType, setFilterType] = useState('title');
+  const [filterValue, setFilterValue] = useState('');
+  const [checked, setChecked] = useState([]);
+  const [sort, setSort] = useState({ attribute: '', order: 'desc' });
+
+  const onFilterValueChange = value => {
+    setFilterValue(value);
+  };
+
+  const onFilterValueClear = () => setFilterValue('');
+
+  const onFilterTypeChange = value => {
+    onFilterValueClear();
+    setFilterType(value);
+  };
+
+  const isSelected = entry => checked.some(item => item.id === entry.id);
+
+  const anySelected = checked.length > 0;
+
+  const toggleSelected = (entry, isEntrySelected) => {
+    if (isEntrySelected) {
+      setChecked(checked.filter(item => item.id !== entry.id));
+    } else {
+      setChecked([entry, ...checked]);
+    }
+  };
+
+  const toggleSelectAll = () => {
+    const allFixable = fixableEntries(preupgradeReports);
+
+    if (checked.length === allFixable.length) {
+      setChecked([]);
+    } else {
+      setChecked(allFixable);
+    }
+  };
+
+  const changeSort = value => {
+    setSort({ ...sort, ...value });
+  };
+
+  return (
+    <React.Fragment>
+      <Row>
+        <div className="col-md-8">
+          <EntriesFilter
+            filterType={filterType}
+            onFilterTypeChange={onFilterTypeChange}
+            filterValue={filterValue}
+            onFilterValueChange={onFilterValueChange}
+          />
+        </div>
+        <div className="col-md-4">
+          <div className="btn-toolbar pull-right">
+            <FixSelectedButton
+              postUrl={newJobInvocationUrl}
+              disabled={!anyEntriesFixable(preupgradeReports) || !anySelected}
+              csrfToken={csrfToken}
+              ids={idsForInvocationFromEntries(checked)}
+            />
+            <UpgradeAllButton
+              postUrl={newJobInvocationUrl}
+              csrfToken={csrfToken}
+              preupgradeReports={preupgradeReports}
+            />
+          </div>
+        </div>
+      </Row>
+      <PreupgradeReportsList
+        allEntries={filterEntries(
+          filterType,
+          filterValue,
+          sortEntries(flattenEntries(preupgradeReports), sort)
+        )}
+        isSelected={isSelected}
+        toggleSelected={toggleSelected}
+        sort={sort}
+        changeSort={changeSort}
+        toggleSelectAll={toggleSelectAll}
+      />
+    </React.Fragment>
+  );
+};
+
+const withLoadingState = Component => props => {
+  const { error, loading, preupgradeReports, reportsExpected } = props;
+
+  if (!isEmpty(error)) {
     return (
       <MessageBox
         key="preupgrade-reports-error"
@@ -18,15 +125,19 @@ const PreupgradeReports = ({ preupgradeReports, loading, error }) => {
 
   return (
     <LoadingState loading={loading}>
-      <PreupgradeReportsList preupgradeReports={preupgradeReports} />
+      {preupgradeReports.length > 0 ? (
+        <Component {...props} />
+      ) : (
+        <NoReports reportsExpected={reportsExpected} />
+      )}
     </LoadingState>
   );
 };
 
 PreupgradeReports.propTypes = {
   preupgradeReports: PropTypes.array.isRequired,
-  loading: PropTypes.bool.isRequired,
-  error: PropTypes.object.isRequired,
+  csrfToken: PropTypes.string.isRequired,
+  newJobInvocationUrl: PropTypes.string.isRequired,
 };
 
-export default PreupgradeReports;
+export default withLoadingState(PreupgradeReports);

data/webpack/components/PreupgradeReports/PreupgradeReportsActions.js

@@ -7,7 +7,7 @@ import {
   PREUPGRADE_REPORTS_FAILURE,
 } from '../../consts';
 
-export const getPreupgradeReports = url => async dispatch => {
+export const getPreupgradeReportsAction = url => async dispatch => {
   dispatch({ type: PREUPGRADE_REPORTS_REQUEST });
 
   try {

data/webpack/components/PreupgradeReports/PreupgradeReportsHelpers.js

@@ -0,0 +1,152 @@
+import Immutable from 'seamless-immutable';
+
+export const flattenEntries = reports =>
+  reports.reduce((memo, report) => [...memo, ...report.entries], []);
+
+const entryWithFixKind = kind => entry =>
+  entry.detail &&
+  entry.detail.remediations &&
+  entry.detail.remediations.some(remediation => remediation.type === kind);
+
+export const entryFixable = entryWithFixKind('command');
+
+export const isInhibitor = entry =>
+  entry.flags && entry.flags.some(flag => flag === 'inhibitor');
+
+export const filterByInhibitor = value => entry => {
+  const inhibitsUpgrade = isInhibitor(entry);
+
+  if (value === 'yes') {
+    return inhibitsUpgrade;
+  }
+
+  if (value === 'no') {
+    return !inhibitsUpgrade;
+  }
+
+  return true;
+};
+
+export const isEmpty = obj => Object.keys(obj).length === 0;
+
+export const anyEntriesFixable = reports =>
+  reportsToEntries(reports, Array.prototype.some, entryFixable);
+
+export const fixableEntries = reports =>
+  reportsToEntries(reports, Array.prototype.filter, entryFixable);
+
+const reportsToEntries = (reports, iterator, predicate) =>
+  iterator.call(flattenEntries(reports), predicate);
+
+export const idsForInvocationFromEntries = entries =>
+  entries.reduce(
+    (memo, entry) => {
+      if (entryFixable(entry)) {
+        memo.entryIds = [...memo.entryIds, entry.id];
+
+        if (!memo.hostIds.includes(entry.hostId)) {
+          memo.hostIds = [...memo.hostIds, entry.hostId];
+        }
+      }
+      return memo;
+    },
+    { hostIds: [], entryIds: [] }
+  );
+
+export const idsForInvocationFromReports = reports =>
+  idsForInvocationFromEntries(flattenEntries(reports));
+
+export const entriesPage = (entries, pagination) => {
+  const offset = (pagination.page - 1) * pagination.perPage;
+
+  return entries.slice(offset, offset + pagination.perPage);
+};
+
+export const filterEntries = (attribute, value, entries) => {
+  if (!value) {
+    return entries;
+  }
+
+  if (attribute === 'fix') {
+    return entries.filter(entryWithFixKind(value));
+  }
+
+  if (attribute === 'inhibitor') {
+    return entries.filter(filterByInhibitor(value));
+  }
+
+  return entries.filter(entry =>
+    entry[attribute].toLowerCase().includes(value.toLowerCase())
+  );
+};
+
+export const byText = attribute => (first, second) => {
+  const firstAttr = first[attribute].toLowerCase();
+  const secondAttr = second[attribute].toLowerCase();
+
+  if (firstAttr < secondAttr) {
+    return -1;
+  }
+
+  if (firstAttr > secondAttr) {
+    return 1;
+  }
+  return 0;
+};
+
+export const bySeverity = attribute => (first, second) => {
+  const sevList = ['info', 'low', 'medium', 'high'];
+
+  const firstAttr = first[attribute].toLowerCase();
+  const secondAttr = second[attribute].toLowerCase();
+
+  return sevList.indexOf(firstAttr) - sevList.indexOf(secondAttr);
+};
+
+export const byFix = (first, second) => {
+  const firstAttr = !!(first.detail && first.detail.remediations);
+  const secondAttr = !!(second.detail && second.detail.remediations);
+  return byBoolComparison(firstAttr, secondAttr);
+};
+
+export const byInhibitor = (first, second) =>
+  byBoolComparison(isInhibitor(first), isInhibitor(second));
+
+const byBoolComparison = (first, second) => {
+  if (first === second) {
+    return 0;
+  }
+
+  if (first) {
+    return -1;
+  }
+  return 1;
+};
+
+export const sortEntries = (entries, sort) => {
+  const entriesCopy = Immutable.asMutable(entries);
+
+  if (!sort.attribute) {
+    return entriesCopy;
+  }
+
+  let sorted;
+
+  if (['title', 'hostname'].includes(sort.attribute)) {
+    sorted = entriesCopy.sort(byText(sort.attribute));
+  }
+
+  if (sort.attribute === 'severity') {
+    sorted = entriesCopy.sort(bySeverity(sort.attribute));
+  }
+
+  if (sort.attribute === 'fix') {
+    sorted = entriesCopy.sort(byFix);
+  }
+
+  if (sort.attribute === 'inhibitor') {
+    sorted = entriesCopy.sort(byInhibitor);
+  }
+
+  return sort.order === 'asc' ? sorted : sorted.reverse();
+};

data/webpack/components/PreupgradeReports/PreupgradeReportsReducer.js

@@ -8,6 +8,7 @@ import {
 
 export const initialState = Immutable({
   loadingPreupgradeReports: false,
+  reportsExpected: false,
   preupgradeReports: [],
   error: {},
 });
@@ -21,6 +22,7 @@ const reducer = (state = initialState, action) => {
       return state.merge({
         loadingPreupgradeReports: false,
         preupgradeReports: payload.results,
+        reportsExpected: true,
       });
     case PREUPGRADE_REPORTS_FAILURE:
       return state.merge({

data/webpack/components/PreupgradeReports/PreupgradeReportsSelectors.js

@@ -2,6 +2,17 @@ export const selectPreupgrade = state => state.foremanLeapp.preupgrade;
 
 export const selectPreupgradeReports = state =>
   selectPreupgrade(state).preupgradeReports;
+
 export const selectLoadingPreupgradeReports = state =>
   selectPreupgrade(state).loadingPreupgradeReports;
 export const selectError = state => selectPreupgrade(state).error;
+
+export const selectReportsExpected = state =>
+  selectPreupgrade(state).reportsExpected;
+
+export const selectRexState = state => state.foremanRemoteExecutionReducers;
+
+export const selectJobInvocations = state =>
+  selectRexState(state).jobInvocations;
+export const selectJobInvocationsPolling = state =>
+  selectJobInvocations(state).isPolling;

data/webpack/components/PreupgradeReports/__tests__/PreupgradeReports.fixtures.js

@@ -2,14 +2,84 @@ export const preupgradeReports = [
   {
     hostId: 5,
     entries: [
-      { title: 'Fix me!', severity: 'Too severe to talk about' },
+      {
+        title: 'Fix me!',
+        severity: 'info',
+        id: 42,
+        hostname: 'host.example.com',
+        flags: [],
+      },
+      {
+        title: 'I am broken too',
+        severity: 'medium',
+        id: 43,
+        hostname: 'host.example.com',
+        flags: [],
+      },
+    ],
+  },
+  {
+    hostId: 6,
+    entries: [
+      {
+        title: 'Octocat is not happy',
+        severity: 'high',
+        id: 44,
+        hostname: 'foo.example.com',
+        flags: ['inhibitor'],
+      },
+      {
+        title: 'Not enough credits',
+        severity: 'low',
+        id: 45,
+        hostname: 'foo.example.com',
+        flags: [],
+      },
+      {
+        title: 'SELinux is turned off',
+        severity: 'medium',
+        id: 46,
+        hostname: 'foo.example.com',
+        flags: [],
+      },
+      {
+        title: 'Root password is too short',
+        severity: 'medium',
+        id: 47,
+        hostname: 'foo.example.com',
+        flags: [],
+      },
+      {
+        title: 'No chocolate chip cookies in cookie jar',
+        severity: 'high',
+        id: 49,
+        hostname: 'foo.example.com',
+        flags: [],
+      },
+    ],
+  },
+];
+
+export const reportsWithRemediations = [
+  {
+    hostId: 5,
+    entries: [
+      {
+        title: 'Fix me!',
+        severity: 'info',
+        detail: { remediations: [{ type: 'hint' }] },
+      },
       { title: 'I am broken too', severity: 'medium' },
     ],
   },
   {
     hostId: 6,
     entries: [
-      { title: 'Octocat is not happy', severity: 'high' },
+      {
+        title: 'Octocat is not happy',
+        severity: 'high',
+        detail: { remediations: [{ type: 'command' }] },
+      },
       { title: 'Not enough credits', severity: 'low' },
     ],
   },