foreman_remote_execution 3.3.7 → 4.0.0

data/test/functional/job_invocations_controller_test.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'test_plugin_helper'
+require_relative '../support/remote_execution_helper'
 
 class JobInvocationsControllerTest < ActionController::TestCase
   test 'should parse inputs coming from the URL params' do
@@ -58,4 +59,74 @@ class JobInvocationsControllerTest < ActionController::TestCase
     post :new, params: params, session: set_session_user
     assert_response :success
   end
+
+  context 'restricted access' do
+    setup do
+      @admin = users(:admin)
+      @user = FactoryBot.create(:user, mail: 'test23@test.foreman.com', admin: false)
+      @invocation = FactoryBot.create(:job_invocation, :with_template, :with_task)
+      @invocation2 = FactoryBot.create(:job_invocation, :with_template, :with_task)
+
+      @invocation.task.update(user: @admin)
+      @invocation2.task.update(user: @user)
+
+      setup_user 'view', 'hosts', nil, @user
+      setup_user 'view', 'job_invocations', 'user = current_user', @user
+      setup_user 'create', 'job_invocations', 'user = current_user', @user
+      setup_user 'cancel', 'job_invocations', 'user = current_user', @user
+    end
+
+    context 'without user filter' do
+      test '#index' do
+        get :index, session: prepare_user(@admin)
+        assert_response :success
+        assert 2, assigns(:job_invocations).size
+      end
+
+      test '#show' do
+        get :show, params: { id: @invocation2.id }, session: prepare_user(@admin)
+        assert_response :success
+      end
+
+      test '#rerun' do
+        get :rerun, params: { id: @invocation2.id }, session: prepare_user(@admin)
+        assert_response :success
+      end
+
+      test '#cancel' do
+        ForemanTasks::Task.any_instance.expects(:cancel).returns(true)
+        post :cancel, params: { id: @invocation2.id }, session: prepare_user(@admin)
+        assert_response :redirect
+      end
+    end
+
+    context 'with user filter' do
+      test '#index' do
+        get :index, session: prepare_user(@user)
+        assert_response :success
+        assert_equal 1, assigns(:job_invocations).size
+        assert_equal @invocation2, assigns(:job_invocations)[0]
+      end
+
+      test '#show' do
+        get :show, params: { id: @invocation.id }, session: prepare_user(@user)
+        assert_response :not_found
+      end
+
+      test '#rerun' do
+        get :rerun, params: { id: @invocation.id }, session: prepare_user(@user)
+        assert_response :not_found
+      end
+
+      test 'cancel' do
+        post :cancel, params: { id: @invocation.id }, session: prepare_user(@user)
+        assert_response :not_found
+      end
+    end
+  end
+
+  def prepare_user(user)
+    User.current = user
+    set_session_user(user)
+  end
 end

data/test/support/remote_execution_helper.rb

@@ -0,0 +1,5 @@
+module RemoteExecutionHelper
+  def job_invocation_task_buttons(task)
+    return []
+  end
+end

data/test/unit/actions/run_host_job_test.rb

@@ -12,7 +12,7 @@ module ForemanRemoteExecution
       let(:provider) do
         provider = ::SSHExecutionProvider
         provider.expects(:ssh_password).with(host).returns('sshpass')
-        provider.expects(:sudo_password).with(host).returns('sudopass')
+        provider.expects(:effective_user_password).with(host).returns('sudopass')
         provider.expects(:ssh_key_passphrase).with(host).returns('keypass')
         provider
       end
@@ -21,7 +21,7 @@ module ForemanRemoteExecution
         secrets = subject.secrets(host, job_invocation, provider)
 
         assert_equal 'sshpass', secrets[:ssh_password]
-        assert_equal 'sudopass', secrets[:sudo_password]
+        assert_equal 'sudopass', secrets[:effective_user_password]
         assert_equal 'keypass', secrets[:key_passphrase]
       end
 
@@ -31,7 +31,7 @@ module ForemanRemoteExecution
         secrets = subject.secrets(host, job_invocation, provider)
 
         assert_equal 'jobsshpass', secrets[:ssh_password]
-        assert_equal 'sudopass', secrets[:sudo_password]
+        assert_equal 'sudopass', secrets[:effective_user_password]
         assert_equal 'jobkeypass', secrets[:key_passphrase]
       end
     end

data/test/unit/actions/run_hosts_job_test.rb

@@ -14,7 +14,7 @@ module ForemanRemoteExecution
         invocation.description = 'Some short description'
         invocation.password = 'changeme'
         invocation.key_passphrase = 'changemetoo'
-        invocation.sudo_password = 'sudopassword'
+        invocation.effective_user_password = 'sudopassword'
         invocation.save
       end
     end

data/test/unit/job_invocation_composer_test.rb

@@ -523,15 +523,15 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
         end
       end
 
-      describe '#sudo_password' do
-        let(:sudo_password) { 'password' }
+      describe '#effective_user_password' do
+        let(:effective_user_password) { 'password' }
         let(:params) do
-          { :job_invocation => { :sudo_password => sudo_password }}
+          { :job_invocation => { :effective_user_password => effective_user_password }}
         end
 
-        it 'sets the sudo password properly' do
+        it 'sets the effective_user_password password properly' do
           composer
-          _(composer.job_invocation.sudo_password).must_equal sudo_password
+          _(composer.job_invocation.effective_user_password).must_equal effective_user_password
         end
       end
 

data/test/unit/remote_execution_provider_test.rb

@@ -78,12 +78,12 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
       end
     end
 
-    describe 'sudo password' do
-      it 'uses the remote_execution_sudo_password on the host param' do
-        host.params['remote_execution_sudo_password'] = 'mypassword'
-        host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_sudo_password', :value => 'mypassword')
-        assert_not proxy_options.key?(:sudo_password)
-        _(secrets[:sudo_password]).must_equal 'mypassword'
+    describe 'effective user password' do
+      it 'uses the remote_execution_effective_user_password on the host param' do
+        host.params['remote_execution_effective_user_password'] = 'mypassword'
+        host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_effective_user_password', :value => 'mypassword')
+        assert_not proxy_options.key?(:effective_user_password)
+        _(secrets[:effective_user_password]).must_equal 'mypassword'
       end
     end
 

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

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

data/webpack/__mocks__/foremanReact/components/SearchBar.js

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

data/webpack/__mocks__/foremanReact/constants.js

@@ -1,3 +1,24 @@
 export const STATUS = {
+  PENDING: 'PENDING',
+  RESOLVED: 'RESOLVED',
   ERROR: 'ERROR',
 };
+
+export const getControllerSearchProps = (
+  controller,
+  id = 'searchBar',
+  canCreate = true
+) => ({
+  controller,
+  autocomplete: {
+    id,
+    searchQuery: '',
+    url: `${controller}/auto_complete_search`,
+    useKeyShortcuts: true,
+  },
+  bookmarks: {
+    url: '/api/bookmarks',
+    canCreate,
+    documentationUrl: `4.1.5Searching`,
+  },
+});

data/webpack/__mocks__/foremanReact/redux/API/APISelectors.js

@@ -0,0 +1,2 @@
+export const selectAPIStatus = () => 'RESOLVED';
+export const selectAPIResponse = state => state;

data/webpack/__mocks__/foremanReact/redux/middlewares/IntervalMiddleware/IntervalSelectors.js

@@ -0,0 +1 @@
+export const selectDoesIntervalExist = () => false;

data/webpack/react_app/components/TargetingHosts/TargetingHosts.js

@@ -5,8 +5,8 @@ import { LoadingState, Alert } from 'patternfly-react';
 import { STATUS } from 'foremanReact/constants';
 import HostItem from './components/HostItem';
 
-const TargetingHosts = ({ status, items }) => {
-  if (status === STATUS.ERROR) {
+const TargetingHosts = ({ apiStatus, items }) => {
+  if (apiStatus === STATUS.ERROR) {
     return (
       <Alert type="error">
         {__(
@@ -16,8 +16,24 @@ const TargetingHosts = ({ status, items }) => {
     );
   }
 
+  const tableBodyRows = items.length ? (
+    items.map(({ name, link, status, actions }) => (
+      <HostItem
+        key={name}
+        name={name}
+        link={link}
+        status={status}
+        actions={actions}
+      />
+    ))
+  ) : (
+    <tr>
+      <td colSpan="3">{__('No hosts found.')}</td>
+    </tr>
+  );
+
   return (
-    <LoadingState loading={!items.length && status === STATUS.PENDING}>
+    <LoadingState loading={!items.length && apiStatus === STATUS.PENDING}>
       <div>
         <table className="table table-bordered table-striped table-hover">
           <thead>
@@ -27,17 +43,7 @@ const TargetingHosts = ({ status, items }) => {
               <th>{__('Actions')}</th>
             </tr>
           </thead>
-          <tbody>
-            {items.map(host => (
-              <HostItem
-                key={host.name}
-                name={host.name}
-                link={host.link}
-                status={host.status}
-                actions={host.actions}
-              />
-            ))}
-          </tbody>
+          <tbody>{tableBodyRows}</tbody>
         </table>
       </div>
     </LoadingState>
@@ -45,7 +51,7 @@ const TargetingHosts = ({ status, items }) => {
 };
 
 TargetingHosts.propTypes = {
-  status: PropTypes.string.isRequired,
+  apiStatus: PropTypes.string.isRequired,
   items: PropTypes.array.isRequired,
 };
 

data/webpack/react_app/components/TargetingHosts/TargetingHostsHelpers.js

@@ -0,0 +1,10 @@
+import { getURI } from 'foremanReact/common/urlHelpers';
+
+export const getApiUrl = (searchQuery, pagination) => {
+  const baseUrl = getURI()
+    .search('')
+    .addQuery('page', pagination.page)
+    .addQuery('per_page', pagination.perPage);
+
+  return searchQuery ? baseUrl.addQuery('search', searchQuery) : baseUrl;
+};

data/webpack/react_app/components/TargetingHosts/TargetingHostsPage.js

@@ -0,0 +1,62 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Grid } from 'patternfly-react';
+
+import SearchBar from 'foremanReact/components/SearchBar';
+import Pagination from 'foremanReact/components/Pagination/PaginationWrapper';
+import { getControllerSearchProps } from 'foremanReact/constants';
+
+import TargetingHosts from './TargetingHosts';
+import './TargetingHostsPage.scss';
+
+const TargetingHostsPage = ({
+  handleSearch,
+  searchQuery,
+  apiStatus,
+  items,
+  totalHosts,
+  pagination,
+  handlePagination,
+}) => (
+  <div id="targeting_hosts">
+    <Grid.Row>
+      <Grid.Col md={6} className="title_filter">
+        <SearchBar
+          onSearch={query => handleSearch(query)}
+          data={{
+            ...getControllerSearchProps('hosts'),
+            autocomplete: {
+              id: 'targeting_hosts_search',
+              searchQuery,
+              url: '/hosts/auto_complete_search',
+              useKeyShortcuts: true,
+            },
+            bookmarks: {},
+          }}
+        />
+      </Grid.Col>
+    </Grid.Row>
+    <br />
+    <TargetingHosts apiStatus={apiStatus} items={items} />
+    <Pagination
+      viewType="list"
+      itemCount={totalHosts}
+      pagination={pagination}
+      onChange={args => handlePagination(args)}
+      dropdownButtonId="targeting-hosts-pagination-dropdown"
+      className="targeting-hosts-pagination"
+    />
+  </div>
+);
+
+TargetingHostsPage.propTypes = {
+  handleSearch: PropTypes.func.isRequired,
+  searchQuery: PropTypes.string.isRequired,
+  apiStatus: PropTypes.string.isRequired,
+  items: PropTypes.array.isRequired,
+  totalHosts: PropTypes.number.isRequired,
+  pagination: PropTypes.object.isRequired,
+  handlePagination: PropTypes.func.isRequired,
+};
+
+export default TargetingHostsPage;

data/webpack/react_app/components/TargetingHosts/TargetingHostsPage.scss

@@ -0,0 +1,6 @@
+.targeting-hosts-pagination {
+  margin-top: -7px;
+}
+#targeting_hosts {
+  min-height: 350px;
+}

data/webpack/react_app/components/TargetingHosts/TargetingHostsSelectors.js

@@ -2,11 +2,19 @@ import {
   selectAPIStatus,
   selectAPIResponse,
 } from 'foremanReact/redux/API/APISelectors';
+import { selectDoesIntervalExist } from 'foremanReact/redux/middlewares/IntervalMiddleware/IntervalSelectors';
+
 import { TARGETING_HOSTS } from './TargetingHostsConsts';
 
 export const selectItems = state =>
   selectAPIResponse(state, TARGETING_HOSTS).hosts || [];
 
 export const selectAutoRefresh = state =>
-  selectAPIResponse(state, TARGETING_HOSTS).autoRefresh;
-export const selectStatus = state => selectAPIStatus(state, TARGETING_HOSTS);
+  selectAPIResponse(state, TARGETING_HOSTS).autoRefresh || '';
+
+export const selectApiStatus = state => selectAPIStatus(state, TARGETING_HOSTS);
+export const selectTotalHosts = state =>
+  selectAPIResponse(state, TARGETING_HOSTS).total_hosts || 0;
+
+export const selectIntervalExists = state =>
+  selectDoesIntervalExist(state, TARGETING_HOSTS);

data/webpack/react_app/components/TargetingHosts/__tests__/TargetingHostsPage.test.js

@@ -0,0 +1,9 @@
+import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import TargetingHostsPage from '../TargetingHostsPage';
+import { TargetingHostsPageFixtures } from './fixtures';
+
+describe('TargetingHostsPage', () =>
+  testComponentSnapshotsWithFixtures(
+    TargetingHostsPage,
+    TargetingHostsPageFixtures
+  ));

data/webpack/react_app/components/TargetingHosts/__tests__/TargetingHostsSelectors.test.js

@@ -0,0 +1,26 @@
+import { testSelectorsSnapshotWithFixtures } from '@theforeman/test';
+
+import {
+  selectItems,
+  selectAutoRefresh,
+  selectApiStatus,
+  selectTotalHosts,
+  selectIntervalExists,
+} from '../TargetingHostsSelectors';
+
+const state = {
+  hosts: [],
+  autoRefresh: 'true',
+  total_hosts: 0,
+};
+
+const fixtures = {
+  'should return hosts': () => selectItems(state),
+  'should return autoRefresh': () => selectAutoRefresh(state),
+  'should return apiStatus': () => selectApiStatus(state),
+  'should return totalHosts': () => selectTotalHosts(state),
+  'should return intervalExists': () => selectIntervalExists(state),
+};
+
+describe('TargetingHostsSelectors', () =>
+  testSelectorsSnapshotWithFixtures(fixtures));

data/webpack/react_app/components/TargetingHosts/__tests__/__snapshots__/TargetingHosts.test.js.snap

@@ -33,6 +33,13 @@ exports[`TargetingHosts renders 1`] = `
           name="host"
           status="success"
         />
+        <HostItem
+          actions={Array []}
+          key="host2"
+          link="/link2"
+          name="host2"
+          status="success"
+        />
       </tbody>
     </table>
   </div>
@@ -52,7 +59,7 @@ exports[`TargetingHosts renders with error 1`] = `
 exports[`TargetingHosts renders with loading 1`] = `
 <LoadingState
   additionalClasses=""
-  loading={false}
+  loading={true}
   loadingText="Loading"
   size="lg"
   timeout={300}
@@ -74,7 +81,15 @@ exports[`TargetingHosts renders with loading 1`] = `
           </th>
         </tr>
       </thead>
-      <tbody />
+      <tbody>
+        <tr>
+          <td
+            colSpan="3"
+          >
+            No hosts found.
+          </td>
+        </tr>
+      </tbody>
     </table>
   </div>
 </LoadingState>