foreman_rh_cloud 13.0.7 → 13.0.9

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)
+
+    # Clear task output
+    TaskOutputLine.delete_all
+    TaskOutputStatus.delete_all
+  end
+
+  test 'plan sets input correctly' do
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @filename,
+      @organization.id
+    )
+
+    assert_equal @filename, action.input[:filename]
+    assert_equal @organization.id, action.input[:organization_id]
+    assert_equal "upload_for_#{@organization.id}", action.input[:instance_label]
+  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_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @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_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @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(:read).with('/fake/cert.pem').returns('FOREMAN CERTIFICATE')
+    File.stubs(:read).with('/fake/key.pem').returns('FOREMAN KEY')
+
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @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_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @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)
+    File.stubs(:read).with('/fake/cert.pem').returns('FOREMAN CERTIFICATE')
+    File.stubs(:read).with('/fake/key.pem').returns('FOREMAN KEY')
+
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @filename,
+      @organization.id
+    )
+
+    cert = action.send(:certificate)
+    assert_equal 'FOREMAN CERTIFICATE', cert[:cert]
+    assert_equal 'FOREMAN KEY', cert[:key]
+  end
+
+  test 'filename returns input filename' do
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @filename,
+      @organization.id
+    )
+
+    assert_equal @filename, action.send(:filename)
+  end
+
+  test 'organization returns Organization from input organization_id' do
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @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_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @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_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @filename,
+      @organization.id
+    )
+
+    refute action.send(:content_disconnected?)
+  end
+
+  test 'instance_label returns label from input' do
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @filename,
+      @organization.id
+    )
+
+    assert_equal "upload_for_#{@organization.id}", action.send(:instance_label)
+  end
+
+  test 'clears previous task output on plan' do
+    # Create some old output
+    old_label = ForemanInventoryUpload::Async::UploadReportDirectJob.output_label(@organization.id)
+    TaskOutputLine.create!(label: old_label, line: 'old line')
+    TaskOutputStatus.create!(label: old_label, status: 'old status')
+
+    create_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @filename,
+      @organization.id
+    )
+
+    # Verify old output was cleared
+    assert_equal 0, TaskOutputLine.where(label: old_label).count
+    assert_equal 0, TaskOutputStatus.where(label: old_label).count
+  end
+
+  test 'rescue_strategy_for_self returns Fail strategy' do
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @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_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @filename,
+      @organization.id
+    )
+
+    # Should raise the error (handled by Dynflow retry mechanism)
+    assert_raises(RestClient::InternalServerError) do
+      action.send(:try_execute)
+    end
+
+    # Verify progress output shows error
+    label = ForemanInventoryUpload::Async::UploadReportDirectJob.output_label(@organization.id)
+    output = ForemanInventoryUpload::Async::ProgressOutput.get(label).full_output
+    assert_match(/Upload failed/, output)
+  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_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @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
+
+    # Verify progress output shows error
+    label = ForemanInventoryUpload::Async::UploadReportDirectJob.output_label(@organization.id)
+    output = ForemanInventoryUpload::Async::ProgressOutput.get(label).full_output
+    assert_match(/Upload failed/, output)
+  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_and_plan_action(
+      ForemanInventoryUpload::Async::UploadReportDirectJob,
+      @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.touch(test_file)
+
+    begin
+      action = create_and_plan_action(
+        ForemanInventoryUpload::Async::UploadReportDirectJob,
+        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"
+
+      # Verify progress output mentions missing certificate
+      label = ForemanInventoryUpload::Async::UploadReportDirectJob.output_label(@organization.id)
+      output = ForemanInventoryUpload::Async::ProgressOutput.get(label).full_output
+      assert_match(/Skipping organization.*no candlepin certificate/, output)
+
+      # Verify status indicates abortion
+      status = ForemanInventoryUpload::Async::ProgressOutput.get(label).status
+      assert_match(/exit 1/, status)
+    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.touch(test_file)
+
+    begin
+      action = create_and_plan_action(
+        ForemanInventoryUpload::Async::UploadReportDirectJob,
+        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"
+
+      # Verify progress output
+      label = ForemanInventoryUpload::Async::UploadReportDirectJob.output_label(@organization.id)
+      output = ForemanInventoryUpload::Async::ProgressOutput.get(label).full_output
+      assert_match(/connection to Insights is not enabled/, output)
+    ensure
+      FileUtils.rm_f(test_file) if File.exist?(test_file)
+    end
+  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/lib/foreman_rh_cloud/registration_manager_extensions_test.rb

@@ -0,0 +1,192 @@
+require 'test_plugin_helper'
+
+module ForemanRhCloud
+  class RegistrationManagerExtensionsTest < ActiveSupport::TestCase
+    setup do
+      @org = FactoryBot.create(:organization)
+      @host = FactoryBot.create(:host, :managed, organization: @org)
+      @insights_facet = ::InsightsFacet.create!(host: @host, uuid: 'test-uuid-123')
+
+      # Stub Candlepin interaction (from Katello)
+      ::Katello::Resources::Candlepin::Consumer.stubs(:destroy)
+
+      # Stub the cloud request to avoid actual HTTP calls
+      Katello::RegistrationManager.stubs(:execute_cloud_request).returns(true)
+    end
+
+    context 'unregister_host' do
+      test 'should call HBI delete in IoP mode when host has insights facet with UUID' do
+        ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+        expected_url = ForemanInventoryUpload.host_by_id_url('test-uuid-123')
+
+        # Expect the cloud request to be made
+        Katello::RegistrationManager.expects(:execute_cloud_request).with do |params|
+          params[:organization] == @org &&
+            params[:method] == :delete &&
+            params[:url] == expected_url &&
+            params[:headers][:content_type] == :json
+        end.returns(true)
+
+        Katello::RegistrationManager.unregister_host(@host, unregistering: true)
+
+        # Verify insights_facet was destroyed
+        assert_nil InsightsFacet.find_by(id: @insights_facet.id)
+      end
+
+      test 'should NOT call HBI delete in non-IoP mode' do
+        ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(false)
+
+        # Should NOT attempt to delete from HBI
+        Katello::RegistrationManager.expects(:execute_cloud_request).never
+
+        Katello::RegistrationManager.unregister_host(@host, unregistering: true)
+
+        # Verify insights_facet was still destroyed
+        assert_nil InsightsFacet.find_by(id: @insights_facet.id)
+      end
+
+      test 'should NOT call HBI delete when host has no insights_facet' do
+        host_without_facet = FactoryBot.create(:host, :managed, organization: @org)
+        ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+
+        Katello::RegistrationManager.expects(:execute_cloud_request).never
+
+        assert_nothing_raised do
+          Katello::RegistrationManager.unregister_host(host_without_facet, unregistering: true)
+        end
+      end
+
+      test 'should NOT call HBI delete when host has insights_facet with empty UUID' do
+        host_with_empty_uuid_facet = FactoryBot.create(:host, :managed, organization: @org)
+        empty_uuid_facet = InsightsFacet.create!(host: host_with_empty_uuid_facet, uuid: '')
+        ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+
+        Katello::RegistrationManager.expects(:execute_cloud_request).never
+
+        assert_nothing_raised do
+          Katello::RegistrationManager.unregister_host(host_with_empty_uuid_facet, unregistering: true)
+        end
+
+        assert_nil InsightsFacet.find_by(id: empty_uuid_facet.id)
+      end
+
+      test 'should NOT call HBI delete when insights_facet has no UUID' do
+        facet_id = @insights_facet.id
+        @insights_facet.update(uuid: nil)
+        ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+
+        Katello::RegistrationManager.expects(:execute_cloud_request).never
+
+        Katello::RegistrationManager.unregister_host(@host, unregistering: true)
+
+        # Verify facet was still destroyed
+        assert_nil InsightsFacet.find_by(id: facet_id)
+      end
+
+      test 'should always destroy insights_facet regardless of IoP mode' do
+        facet_id = @insights_facet.id
+        ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(false)
+
+        assert_not_nil InsightsFacet.find_by(id: facet_id)
+
+        Katello::RegistrationManager.unregister_host(@host, unregistering: true)
+
+        assert_nil InsightsFacet.find_by(id: facet_id)
+      end
+    end
+
+    context 'hbi_host_destroy error handling' do
+      setup do
+        ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+        @expected_url = ForemanInventoryUpload.host_by_id_url('test-uuid-123')
+        @facet_id = @insights_facet.id
+        # Unstub execute_cloud_request for error tests
+        Katello::RegistrationManager.unstub(:execute_cloud_request)
+      end
+
+      test 'should handle RestClient::NotFound gracefully' do
+        Katello::RegistrationManager.stubs(:execute_cloud_request).raises(RestClient::NotFound)
+
+        # Should log warning but not raise
+        Rails.logger.expects(:warn).with(regexp_matches(/host does not exist in HBI/))
+
+        assert_nothing_raised do
+          Katello::RegistrationManager.unregister_host(@host, unregistering: true)
+        end
+
+        # Facet should still be destroyed
+        assert_nil InsightsFacet.find_by(id: @facet_id)
+      end
+
+      test 'should handle server errors gracefully' do
+        error = RestClient::InternalServerError.new
+        Katello::RegistrationManager.stubs(:execute_cloud_request).raises(error)
+
+        # Should log error but not raise
+        Rails.logger.expects(:error).with(regexp_matches(/Failed to destroy HBI host/))
+
+        assert_nothing_raised do
+          Katello::RegistrationManager.unregister_host(@host, unregistering: true)
+        end
+
+        # Facet should still be destroyed
+        assert_nil InsightsFacet.find_by(id: @facet_id)
+      end
+
+      test 'should handle timeout errors gracefully' do
+        error = RestClient::Exceptions::ReadTimeout.new
+        Katello::RegistrationManager.stubs(:execute_cloud_request).raises(error)
+
+        # Should log error but not raise
+        Rails.logger.expects(:error).with(regexp_matches(/Failed to destroy HBI host/))
+
+        assert_nothing_raised do
+          Katello::RegistrationManager.unregister_host(@host, unregistering: true)
+        end
+
+        # Facet should still be destroyed
+        assert_nil InsightsFacet.find_by(id: @facet_id)
+      end
+
+      test 'should handle connection errors gracefully' do
+        error = Errno::ECONNREFUSED.new
+        Katello::RegistrationManager.stubs(:execute_cloud_request).raises(error)
+
+        # Should log error but not raise
+        Rails.logger.expects(:error).with(regexp_matches(/Failed to destroy HBI host/))
+
+        assert_nothing_raised do
+          Katello::RegistrationManager.unregister_host(@host, unregistering: true)
+        end
+
+        # Facet should still be destroyed
+        assert_nil InsightsFacet.find_by(id: @facet_id)
+      end
+    end
+
+    context 'integration' do
+      test 'should be properly prepended to RegistrationManager' do
+        assert_includes Katello::RegistrationManager.singleton_class.ancestors,
+          ForemanRhCloud::RegistrationManagerExtensions
+      end
+
+      test 'should preserve original unregister_host behavior' do
+        ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(false)
+
+        # Just verify the extension is properly integrated
+        # Detailed Katello behavior is tested in Katello's own tests
+        assert_nothing_raised do
+          Katello::RegistrationManager.unregister_host(@host, unregistering: true)
+        end
+      end
+    end
+
+    context 'URL generation' do
+      test 'host_by_id_url should return correct format' do
+        url = ForemanInventoryUpload.host_by_id_url('test-uuid-123')
+
+        assert_match %r{/hosts/test-uuid-123$}, url
+      end
+    end
+  end
+end

data/webpack/ForemanColumnExtensions/index.js

@@ -79,6 +79,8 @@ const hostsIndexColumnExtensions = [
     categoryName: insightsCategoryName,
     categoryKey: 'insights',
     isSorted: false,
+    // eslint-disable-next-line camelcase
+    isRelevant: contextData => contextData?.metadata?.foreman_rh_cloud?.iop,
   },
 ];
 

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

@@ -40,7 +40,7 @@ class AccountList extends Component {
     }
 
     const items = Object.keys(filteredAccount).map((label, index) => {
-      const account = accounts[label];
+      const account = filteredAccount[label];
       return <ListItem key={index} label={label} account={account} />;
     });
     return <Accordion className="account-list">{items}</Accordion>;

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,
-    },
+    generate_report_status: 'unknown',
+    upload_report_status: 'unknown',
+    id: 1,
+    report_file_paths: [],
   },
 };

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

@@ -10,8 +10,10 @@ import PropTypes from 'prop-types';
 import ListItemStatus from '../ListItemStatus';
 import Dashboard from '../../../Dashboard';
 
-const ListItem = ({ label, account }) => {
+const ListItem = ({ label, account = {} }) => {
   const [isExpanded, setIsExpanded] = useState(false);
+  const accountId = account?.id ?? 0;
+
   return (
     <AccordionItem>
       <AccordionToggle
@@ -30,7 +32,7 @@ const ListItem = ({ label, account }) => {
         <ListItemStatus key={`${label}_status`} account={account} />
       </AccordionToggle>
       <AccordionContent isHidden={!isExpanded}>
-        <Dashboard accountID={account.id} account={account} />
+        <Dashboard accountID={accountId} account={account} />
       </AccordionContent>
     </AccordionItem>
   );

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",
-          },
+          "generate_report_status": "unknown",
+          "id": 1,
+          "report_file_paths": Array [],
+          "upload_report_status": "unknown",
         }
       }
       key="test_status"
@@ -34,13 +33,13 @@ exports[`ListItem rendering render with Props 1`] = `
     <Connect(Dashboard)
       account={
         Object {
-          "test": Object {
-            "generate_report_status": "unknown",
-            "id": 1,
-            "upload_report_status": "unknown",
-          },
+          "generate_report_status": "unknown",
+          "id": 1,
+          "report_file_paths": Array [],
+          "upload_report_status": "unknown",
         }
       }
+      accountID={1}
     />
   </AccordionContent>
 </AccordionItem>