foreman_rh_cloud 13.0.8 → 13.0.10

data/test/jobs/upload_report_direct_job_test.rb

@@ -0,0 +1,399 @@
+require 'test_plugin_helper'
+require 'foreman_tasks/test_helpers'
+
+class UploadReportDirectJobTest < ActiveSupport::TestCase
+  include Dynflow::Testing::Factories
+  include Dynflow::Testing::Assertions
+
+  setup do
+    @organization = FactoryBot.create(:organization)
+    @uploads_folder = ForemanInventoryUpload.uploads_folder
+    @filename = File.join(@uploads_folder, 'test_report.tar.xz')
+
+    # Stub settings
+    Setting.stubs(:[]).with(:subscription_connection_enabled).returns(true)
+    Setting.stubs(:[]).with(:ssl_certificate).returns('/fake/cert.pem')
+    Setting.stubs(:[]).with(:ssl_priv_key).returns('/fake/key.pem')
+
+    # Stub ForemanRhCloud methods
+    ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(false)
+
+    # Stub organization owner details with certificate
+    @cert_data = {
+      'upstreamConsumer' => {
+        'idCert' => {
+          'cert' => 'FAKE CERTIFICATE',
+          'key' => 'FAKE KEY',
+        },
+      },
+    }
+    Organization.any_instance.stubs(:owner_details).returns(@cert_data)
+  end
+
+  test 'plan sets input correctly' do
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    assert_equal @filename, action.input[:filename]
+    assert_equal @organization.id, action.input[:organization_id]
+  end
+
+  test 'output_label generates correct label' do
+    label = ForemanInventoryUpload::Async::UploadReportDirectJob.output_label(@organization.id)
+    assert_equal "upload_for_#{@organization.id}", label
+  end
+
+  test 'uses manifest certificate in regular mode' do
+    ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(false)
+
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    cert = action.send(:certificate)
+    assert_equal 'FAKE CERTIFICATE', cert[:cert]
+    assert_equal 'FAKE KEY', cert[:key]
+  end
+
+  test 'manifest_certificate extracts from organization owner_details' do
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    cert = action.send(:manifest_certificate)
+    assert_equal 'FAKE CERTIFICATE', cert[:cert]
+    assert_equal 'FAKE KEY', cert[:key]
+  end
+
+  test 'uses foreman certificate in IoP mode' do
+    ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+    File.stubs(:readable?).with('/fake/cert.pem').returns(true)
+    File.stubs(:readable?).with('/fake/key.pem').returns(true)
+    File.stubs(:read).with('/fake/cert.pem').returns('FOREMAN CERTIFICATE')
+    File.stubs(:read).with('/fake/key.pem').returns('FOREMAN KEY')
+
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    cert = action.send(:foreman_certificate)
+    assert_equal 'FOREMAN CERTIFICATE', cert[:cert]
+    assert_equal 'FOREMAN KEY', cert[:key]
+  end
+
+  test 'certificate method returns manifest cert in regular mode' do
+    ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(false)
+
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    cert = action.send(:certificate)
+    assert_equal 'FAKE CERTIFICATE', cert[:cert]
+    assert_equal 'FAKE KEY', cert[:key]
+  end
+
+  test 'certificate method returns foreman cert in IoP mode' do
+    ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+    Setting.stubs(:[]).with(:ssl_certificate).returns('/fake/cert.pem')
+    Setting.stubs(:[]).with(:ssl_priv_key).returns('/fake/key.pem')
+    File.stubs(:readable?).with('/fake/cert.pem').returns(true)
+    File.stubs(:readable?).with('/fake/key.pem').returns(true)
+    File.stubs(:read).with('/fake/cert.pem').returns('FOREMAN CERTIFICATE')
+    File.stubs(:read).with('/fake/key.pem').returns('FOREMAN KEY')
+
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    cert = action.send(:certificate)
+    assert_equal 'FOREMAN CERTIFICATE', cert[:cert]
+    assert_equal 'FOREMAN KEY', cert[:key]
+  end
+
+  test 'foreman_certificate raises error when certificate file is missing' do
+    ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+    Setting.stubs(:[]).with(:ssl_certificate).returns('/nonexistent/cert.pem')
+    Setting.stubs(:[]).with(:ssl_priv_key).returns('/fake/key.pem')
+    File.stubs(:readable?).with('/nonexistent/cert.pem').returns(false)
+
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    error = assert_raises(RuntimeError) do
+      action.send(:foreman_certificate)
+    end
+    assert_match(/SSL certificate file not found or not readable/, error.message)
+  end
+
+  test 'foreman_certificate raises error when private key file is missing' do
+    ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+    Setting.stubs(:[]).with(:ssl_certificate).returns('/fake/cert.pem')
+    Setting.stubs(:[]).with(:ssl_priv_key).returns('/nonexistent/key.pem')
+    File.stubs(:readable?).with('/fake/cert.pem').returns(true)
+    File.stubs(:readable?).with('/nonexistent/key.pem').returns(false)
+
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    error = assert_raises(RuntimeError) do
+      action.send(:foreman_certificate)
+    end
+    assert_match(/SSL private key file not found or not readable/, error.message)
+  end
+
+  test 'filename returns input filename' do
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    assert_equal @filename, action.send(:filename)
+  end
+
+  test 'organization returns Organization from input organization_id' do
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    org = action.send(:organization)
+    assert_equal @organization.id, org.id
+  end
+
+  test 'content_disconnected? returns true when subscription_connection_enabled is false' do
+    Setting.stubs(:[]).with(:subscription_connection_enabled).returns(false)
+
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    assert action.send(:content_disconnected?)
+  end
+
+  test 'content_disconnected? returns false when subscription_connection_enabled is true' do
+    Setting.stubs(:[]).with(:subscription_connection_enabled).returns(true)
+
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    refute action.send(:content_disconnected?)
+  end
+
+  test 'content_disconnected? returns false when IoP mode is enabled even if subscription_connection_enabled is false' do
+    Setting.stubs(:[]).with(:subscription_connection_enabled).returns(false)
+    ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    refute action.send(:content_disconnected?)
+  end
+
+  test 'rescue_strategy_for_self returns Fail strategy' do
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    assert_equal Dynflow::Action::Rescue::Fail, action.send(:rescue_strategy_for_self)
+  end
+
+  test 'handles RestClient server error gracefully' do
+    # Create mock response for RestClient exception
+    response = mock('response')
+    response.stubs(:code).returns(500)
+    response.stubs(:body).returns('Server error')
+
+    # Stub upload_file to raise server error
+    ForemanInventoryUpload::Async::UploadReportDirectJob.any_instance.stubs(:upload_file)
+                                                        .raises(RestClient::InternalServerError.new(response))
+
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    # Should raise the error (handled by Dynflow retry mechanism)
+    assert_raises(RestClient::InternalServerError) do
+      action.send(:try_execute)
+    end
+  end
+
+  test 'handles RestClient timeout gracefully' do
+    # Stub upload_file to raise timeout (Timeout exception doesn't need response object)
+    ForemanInventoryUpload::Async::UploadReportDirectJob.any_instance.stubs(:upload_file)
+                                                        .raises(RestClient::Exceptions::Timeout.new)
+
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    # Should raise the error (handled by Dynflow retry mechanism via ExponentialBackoff)
+    assert_raises(RestClient::Exceptions::Timeout) do
+      action.send(:try_execute)
+    end
+  end
+
+  test 'uses proxy configuration from ForemanRhCloud' do
+    proxy_url = 'http://proxy.example.com:8080'
+    ForemanRhCloud.stubs(:transformed_http_proxy_string).returns(proxy_url)
+
+    # Create test file
+    FileUtils.mkdir_p(File.dirname(@filename))
+    FileUtils.touch(@filename)
+
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+    plan_action(action, @filename, @organization.id)
+
+    # Mock response
+    response = mock('response')
+    response.stubs(:code).returns(200)
+
+    # Verify execute_cloud_request is called (which handles proxy)
+    # We can't test the actual proxy parameters because CloudRequest concern
+    # merges them internally, but we can verify the method is called
+    action.expects(:execute_cloud_request).returns(response)
+
+    # Stub upload_file to call execute_cloud_request (avoiding SSL cert creation issues)
+    action.stubs(:upload_file).returns(nil)
+
+    # Manually call upload_file expectations in the test
+    # This simulates what would happen during actual execution
+    action.send(:execute_cloud_request,
+      method: :post,
+      url: ForemanInventoryUpload.upload_url,
+      payload: { multipart: true },
+      headers: { 'X-Org-Id' => @organization.label })
+  end
+
+  test 'file cleanup when upload aborted due to missing certificate' do
+    # Remove certificate from organization
+    Organization.any_instance.stubs(:owner_details).returns({})
+
+    # Create a real test file to verify it's not moved
+    FileUtils.mkdir_p(@uploads_folder)
+    test_file = File.join(@uploads_folder, 'test_file_for_cleanup.tar.xz')
+    FileUtils.mkdir_p(@uploads_folder)
+    FileUtils.touch(test_file)
+
+    begin
+      action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+      action.expects(:action_subject).with(@organization)
+      plan_action(action, test_file, @organization.id)
+
+      # Execute the action
+      action.send(:try_execute)
+
+      # Verify file still exists (not moved or deleted)
+      assert File.exist?(test_file), "File should remain when upload is aborted"
+    ensure
+      FileUtils.rm_f(test_file) if File.exist?(test_file)
+    end
+  end
+
+  test 'file cleanup when upload aborted due to disconnected mode' do
+    Setting.stubs(:[]).with(:subscription_connection_enabled).returns(false)
+
+    # Create a real test file
+    FileUtils.mkdir_p(@uploads_folder)
+    test_file = File.join(@uploads_folder, 'test_file_disconnected.tar.xz')
+    FileUtils.mkdir_p(@uploads_folder)
+    FileUtils.touch(test_file)
+
+    begin
+      action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+      action.expects(:action_subject).with(@organization)
+      plan_action(action, test_file, @organization.id)
+
+      # Execute the action
+      action.send(:try_execute)
+
+      # Verify file still exists
+      assert File.exist?(test_file), "File should remain when connection is disabled"
+    ensure
+      FileUtils.rm_f(test_file) if File.exist?(test_file)
+    end
+  end
+
+  test 'overwrites existing done file and logs warning' do
+    # Prepare new report file in uploads folder
+    FileUtils.mkdir_p(@uploads_folder)
+    source_file = File.join(@uploads_folder, 'overwrite_done_file.tar.xz')
+    new_report_content = 'new report content'
+    File.write(source_file, new_report_content)
+
+    # Pre-create done file with old content
+    done_file_path = ForemanInventoryUpload.done_file_path(File.basename(source_file))
+    FileUtils.mkdir_p(File.dirname(done_file_path))
+    old_report_content = 'old report content'
+    File.write(done_file_path, old_report_content)
+
+    action = create_action(ForemanInventoryUpload::Async::UploadReportDirectJob)
+    action.expects(:action_subject).with(@organization)
+
+    # Stub upload_file to avoid actual HTTP upload
+    action.stubs(:upload_file).returns(nil)
+
+    # Expect a warning when overwriting the existing done file
+    action.expects(:logger).at_least_once.returns(mock_logger = mock('logger'))
+    mock_logger.expects(:warn).with(regexp_matches(/already exists.*overwriting/i))
+    mock_logger.stubs(:debug)
+
+    plan_action(action, source_file, @organization.id)
+
+    # Execute the action (which will call move_to_done_folder)
+    action.send(:try_execute)
+
+    # Done file should now contain the new report content
+    assert_equal new_report_content, File.read(done_file_path)
+  ensure
+    FileUtils.rm_f(source_file) if defined?(source_file) && source_file
+    FileUtils.rm_f(done_file_path) if defined?(done_file_path) && done_file_path
+  end
+
+  test 'FileUpload wrapper delegates to file object' do
+    # Create test file
+    FileUtils.mkdir_p(File.dirname(@filename))
+    FileUtils.touch(@filename)
+
+    file = File.open(@filename, 'rb')
+    begin
+      wrapped = ForemanInventoryUpload::Async::UploadReportDirectJob::FileUpload.new(
+        file,
+        content_type: 'application/test'
+      )
+
+      assert_equal 'application/test', wrapped.content_type
+      assert_equal file.path, wrapped.path
+      assert_respond_to wrapped, :read
+      assert_respond_to wrapped, :close
+    ensure
+      file.close
+    end
+  end
+
+  test 'FileUpload wrapper provides content_type for RestClient' do
+    # Create test file
+    FileUtils.mkdir_p(File.dirname(@filename))
+    FileUtils.touch(@filename)
+
+    file = File.open(@filename, 'rb')
+    begin
+      wrapped = ForemanInventoryUpload::Async::UploadReportDirectJob::FileUpload.new(
+        file,
+        content_type: 'application/vnd.redhat.qpc.tar+tgz'
+      )
+
+      # RestClient checks for these methods
+      assert_respond_to wrapped, :read
+      assert_respond_to wrapped, :path
+      assert_respond_to wrapped, :content_type
+      assert_equal 'application/vnd.redhat.qpc.tar+tgz', wrapped.content_type
+    ensure
+      file.close
+    end
+  end
+end

data/test/unit/rh_cloud_permissions_test.rb

@@ -9,6 +9,8 @@ class RhCloudPermissionsTest < ActiveSupport::TestCase
     [
       'insights_cloud/api/machine_telemetries/forward_request',
       'insights_cloud/api/machine_telemetries/branch_info',
+      'api/v2/rh_cloud/foreman_inventory_upload/api/tasks/current',
+      'api/v2/rh_cloud/foreman_inventory_upload/api/tasks/history',
     ],
     skip_patterns: [/^(?!foreman_inventory_upload|insights_cloud|.*rh_cloud).*/]
   ) # include only plugin paths

data/webpack/ForemanInventoryUpload/Components/AccountList/AccountList.fixtures.js

@@ -3,18 +3,18 @@ import { noop } from 'foremanReact/common/helpers';
 export const accounts = {
   Account1: {
     id: 1,
-    upload_report_status: 'running',
-    generate_report_status: 'running',
+    uploaded_status: 'running',
+    generated_status: 'running',
   },
   Account2: {
     id: 2,
-    upload_report_status: 'unknown',
-    generate_report_status: 'failure',
+    uploaded_status: 'unknown',
+    generated_status: 'failure',
   },
   Account3: {
     id: 3,
-    upload_report_status: 'success',
-    generate_report_status: 'running',
+    uploaded_status: 'success',
+    generated_status: 'running',
   },
 };
 

data/webpack/ForemanInventoryUpload/Components/AccountList/AccountList.js

@@ -1,4 +1,4 @@
-import React, { Component } from 'react';
+import React, { useEffect } from 'react';
 import { isEmpty } from 'lodash';
 import { noop } from 'foremanReact/common/helpers';
 import { Accordion } from '@patternfly/react-core';
@@ -10,42 +10,57 @@ import EmptyResults from './Components/EmptyResults';
 import { filterAccounts } from './AccountListHelper';
 import './accountList.scss';
 
-class AccountList extends Component {
-  componentDidMount() {
-    const { fetchAccountsStatus, startAccountStatusPolling } = this.props;
+const AccountList = ({
+  accounts,
+  error,
+  filterTerm,
+  fetchAccountsStatus,
+  startAccountStatusPolling,
+  stopAccountStatusPolling,
+  pollingProcessID,
+}) => {
+  useEffect(() => {
     fetchAccountsStatus();
-    const pollingProcessID = setInterval(fetchAccountsStatus, 5000);
-    startAccountStatusPolling(pollingProcessID);
-  }
-
-  componentWillUnmount() {
-    const { stopAccountStatusPolling, pollingProcessID } = this.props;
-    stopAccountStatusPolling(pollingProcessID);
-  }
+    const pollingID = setInterval(fetchAccountsStatus, 2000);
+    startAccountStatusPolling(pollingID);
 
-  render() {
-    const { accounts, error, filterTerm } = this.props;
-    const filteredAccount = filterAccounts(accounts, filterTerm);
+    return () => {
+      stopAccountStatusPolling(pollingID);
+    };
+  }, [
+    fetchAccountsStatus,
+    startAccountStatusPolling,
+    stopAccountStatusPolling,
+  ]);
 
-    if (error) {
-      return <ErrorState error={error} />;
-    }
+  const filteredAccount = filterAccounts(accounts, filterTerm);
 
-    if (isEmpty(accounts)) {
-      return <EmptyState />;
-    }
+  if (error) {
+    return <ErrorState error={error} />;
+  }
 
-    if (isEmpty(filteredAccount)) {
-      return <EmptyResults />;
-    }
+  if (isEmpty(accounts)) {
+    return <EmptyState />;
+  }
 
-    const items = Object.keys(filteredAccount).map((label, index) => {
-      const account = accounts[label];
-      return <ListItem key={index} label={label} account={account} />;
-    });
-    return <Accordion className="account-list">{items}</Accordion>;
+  if (isEmpty(filteredAccount)) {
+    return <EmptyResults />;
   }
-}
+
+  const items = Object.keys(filteredAccount).map((label, index) => {
+    const account = accounts[label];
+    return (
+      <ListItem
+        key={label}
+        label={label}
+        account={account}
+        defaultExpanded={index === 0}
+        onTaskStart={fetchAccountsStatus}
+      />
+    );
+  });
+  return <Accordion className="account-list">{items}</Accordion>;
+};
 
 AccountList.propTypes = {
   fetchAccountsStatus: PropTypes.func,
@@ -53,8 +68,8 @@ AccountList.propTypes = {
   stopAccountStatusPolling: PropTypes.func,
   pollingProcessID: PropTypes.number,
   account: PropTypes.shape({
-    generate_report_status: PropTypes.string,
-    upload_report_status: PropTypes.string,
+    generated_status: PropTypes.string,
+    uploaded_status: PropTypes.string,
   }),
   accounts: PropTypes.object,
   error: PropTypes.string,
@@ -67,8 +82,8 @@ AccountList.defaultProps = {
   stopAccountStatusPolling: noop,
   pollingProcessID: 0,
   account: {
-    generate_report_status: 'unknown',
-    upload_report_status: 'unknown',
+    generated_status: 'unknown',
+    uploaded_status: 'unknown',
   },
   accounts: {},
   error: '',

data/webpack/ForemanInventoryUpload/Components/AccountList/AccountListActions.js

@@ -46,10 +46,10 @@ export const restartProcess = (accountID, activeTab) => async dispatch => {
 
   if (activeTab === 'uploading') {
     processController = 'uploads';
-    processStatusName = 'upload_report_status';
+    processStatusName = 'uploaded_status';
   } else {
     processController = 'reports';
-    processStatusName = 'generate_report_status';
+    processStatusName = 'generated_status';
   }
 
   try {

data/webpack/ForemanInventoryUpload/Components/AccountList/Components/ListItem/ListItem.fixtures.js

@@ -1,10 +1,9 @@
 export const props = {
   label: 'test',
   account: {
-    test: {
-      generate_report_status: 'unknown',
-      upload_report_status: 'unknown',
-      id: 1,
-    },
+    generated_status: 'unknown',
+    uploaded_status: 'unknown',
+    id: 1,
+    report_file_paths: [],
   },
 };

data/webpack/ForemanInventoryUpload/Components/AccountList/Components/ListItem/ListItem.js

@@ -10,8 +10,8 @@ import PropTypes from 'prop-types';
 import ListItemStatus from '../ListItemStatus';
 import Dashboard from '../../../Dashboard';
 
-const ListItem = ({ label, account }) => {
-  const [isExpanded, setIsExpanded] = useState(false);
+const ListItem = ({ label, account, defaultExpanded, onTaskStart }) => {
+  const [isExpanded, setIsExpanded] = useState(defaultExpanded);
   return (
     <AccordionItem>
       <AccordionToggle
@@ -30,7 +30,11 @@ const ListItem = ({ label, account }) => {
         <ListItemStatus key={`${label}_status`} account={account} />
       </AccordionToggle>
       <AccordionContent isHidden={!isExpanded}>
-        <Dashboard accountID={account.id} account={account} />
+        <Dashboard
+          accountID={account.id}
+          account={account}
+          onTaskStart={onTaskStart}
+        />
       </AccordionContent>
     </AccordionItem>
   );
@@ -39,18 +43,22 @@ const ListItem = ({ label, account }) => {
 ListItem.propTypes = {
   label: PropTypes.string.isRequired,
   account: PropTypes.shape({
-    generate_report_status: PropTypes.string,
-    upload_report_status: PropTypes.string,
+    generated_status: PropTypes.string,
+    uploaded_status: PropTypes.string,
     id: PropTypes.number,
   }),
+  defaultExpanded: PropTypes.bool,
+  onTaskStart: PropTypes.func,
 };
 
 ListItem.defaultProps = {
   account: {
-    generate_report_status: 'unknown',
-    upload_report_status: 'unknown',
+    generated_status: 'unknown',
+    uploaded_status: 'unknown',
     id: 0,
   },
+  defaultExpanded: false,
+  onTaskStart: null,
 };
 
 export default ListItem;

data/webpack/ForemanInventoryUpload/Components/AccountList/Components/ListItem/__tests__/__snapshots__/ListItem.test.js.snap

@@ -18,11 +18,10 @@ exports[`ListItem rendering render with Props 1`] = `
     <ListItemStatus
       account={
         Object {
-          "test": Object {
-            "generate_report_status": "unknown",
-            "id": 1,
-            "upload_report_status": "unknown",
-          },
+          "generated_status": "unknown",
+          "id": 1,
+          "report_file_paths": Array [],
+          "uploaded_status": "unknown",
         }
       }
       key="test_status"
@@ -31,16 +30,17 @@ exports[`ListItem rendering render with Props 1`] = `
   <AccordionContent
     isHidden={true}
   >
-    <Connect(Dashboard)
+    <Dashboard
       account={
         Object {
-          "test": Object {
-            "generate_report_status": "unknown",
-            "id": 1,
-            "upload_report_status": "unknown",
-          },
+          "generated_status": "unknown",
+          "id": 1,
+          "report_file_paths": Array [],
+          "uploaded_status": "unknown",
         }
       }
+      accountID={1}
+      onTaskStart={null}
     />
   </AccordionContent>
 </AccordionItem>

data/webpack/ForemanInventoryUpload/Components/AccountList/Components/ListItemStatus/ListItemStatus.fixtures.js

@@ -1,7 +1,7 @@
 export const props = {
   account: {
-    generate_report_status: 'Exit Code: pid 22191 exit 0',
-    upload_report_status: 'Exit Code: Running in pid 22376',
+    generated_status: 'success',
+    uploaded_status: 'running',
     label: 'Default Org',
   },
 };