foreman_openbolt 1.0.0 → 1.1.1

data/test/unit/lib/proxy_api/openbolt_test.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class ProxyApiOpenboltTest < ForemanOpenbolt::PluginTestCase
+  PROXY_URL = 'https://proxy.example.com:8443'
+
+  setup do
+    @api = ProxyAPI::Openbolt.new(url: PROXY_URL)
+  end
+
+  context 'task_names' do
+    test 'returns task names from fetched tasks' do
+      tasks = { 'mymod::install' => {}, 'mymod::mytask' => {} }
+      stub_request(:get, "#{PROXY_URL}/openbolt/tasks")
+        .to_return(status: 200, body: tasks.to_json, headers: { 'Content-Type' => 'application/json' })
+
+      assert_equal %w[mymod::install mymod::mytask], @api.task_names
+    end
+  end
+
+  context 'fetch_tasks' do
+    test 'fetches and parses task list from proxy' do
+      tasks = { 'mymod::install' => { 'description' => 'Install a package' } }
+      stub_request(:get, "#{PROXY_URL}/openbolt/tasks")
+        .to_return(status: 200, body: tasks.to_json, headers: { 'Content-Type' => 'application/json' })
+
+      result = @api.fetch_tasks
+      assert_equal tasks, result
+    end
+
+    test 'raises on proxy HTTP error' do
+      stub_request(:get, "#{PROXY_URL}/openbolt/tasks")
+        .to_return(status: 500, body: 'Internal Server Error')
+
+      assert_raises(RestClient::InternalServerError) { @api.fetch_tasks }
+    end
+
+    test 'raises ProxyException on unparseable response body' do
+      stub_request(:get, "#{PROXY_URL}/openbolt/tasks")
+        .to_return(status: 200, body: nil)
+
+      assert_raises(ProxyAPI::ProxyException) { @api.fetch_tasks }
+    end
+
+    test 'raises ProxyException on invalid JSON' do
+      stub_request(:get, "#{PROXY_URL}/openbolt/tasks")
+        .to_return(status: 200, body: 'not json', headers: { 'Content-Type' => 'text/plain' })
+
+      assert_raises(ProxyAPI::ProxyException) { @api.fetch_tasks }
+    end
+  end
+
+  context 'reload_tasks' do
+    test 'fetches from reload endpoint and updates cached tasks' do
+      original_tasks = { 'mymod::install' => { 'description' => 'Install something' } }
+      stub_request(:get, "#{PROXY_URL}/openbolt/tasks")
+        .to_return(status: 200, body: original_tasks.to_json, headers: { 'Content-Type' => 'application/json' })
+
+      assert_equal original_tasks, @api.tasks
+
+      reloaded_tasks = { 'mymod::install' => {}, 'mymod::mytask' => { 'description' => 'A new task' } }
+      stub_request(:get, "#{PROXY_URL}/openbolt/tasks/reload")
+        .to_return(status: 200, body: reloaded_tasks.to_json, headers: { 'Content-Type' => 'application/json' })
+
+      result = @api.reload_tasks
+      assert_equal reloaded_tasks, result
+      assert_equal reloaded_tasks, @api.tasks
+    end
+  end
+
+  context 'openbolt_options' do
+    test 'fetches and parses options from proxy' do
+      options = { 'transport' => { 'type' => 'string', 'default' => 'ssh' } }
+      stub_request(:get, "#{PROXY_URL}/openbolt/tasks/options")
+        .to_return(status: 200, body: options.to_json, headers: { 'Content-Type' => 'application/json' })
+
+      result = @api.openbolt_options
+      assert_equal options, result
+    end
+
+    test 'memoizes the result' do
+      options = { 'transport' => { 'type' => 'string' } }
+      stub = stub_request(:get, "#{PROXY_URL}/openbolt/tasks/options")
+             .to_return(status: 200, body: options.to_json, headers: { 'Content-Type' => 'application/json' })
+
+      @api.openbolt_options
+      @api.openbolt_options
+      assert_requested(stub, times: 1)
+    end
+  end
+
+  context 'launch_task' do
+    test 'posts task request and returns parsed response' do
+      response_body = { 'id' => 'job-abc-123' }
+      stub_request(:post, "#{PROXY_URL}/openbolt/launch/task")
+        .to_return(status: 200, body: response_body.to_json, headers: { 'Content-Type' => 'application/json' })
+
+      result = @api.launch_task(
+        name: 'mymod::install',
+        targets: 'host1.example.com',
+        parameters: { 'name' => 'nginx' },
+        options: { 'transport' => 'ssh' }
+      )
+      assert_equal response_body, result
+    end
+
+    test 'sends correct JSON payload with parameters, options, and targets' do
+      stub = stub_request(:post, "#{PROXY_URL}/openbolt/launch/task")
+             .with do |request|
+        body = JSON.parse(request.body)
+        body['name'] == 'mymod::mytask' &&
+          body['targets'] == 'host1.example.com,host2.example.com' &&
+          body['parameters'] == { 'name' => 'nginx', 'version' => '1.0' } &&
+          body['options'] == { 'transport' => 'ssh', 'run-as' => 'root' }
+      end
+             .to_return(status: 200, body: '{"id": "job-1"}', headers: { 'Content-Type' => 'application/json' })
+
+      @api.launch_task(
+        name: 'mymod::mytask',
+        targets: 'host1.example.com,host2.example.com',
+        parameters: { 'name' => 'nginx', 'version' => '1.0' },
+        options: { 'transport' => 'ssh', 'run-as' => 'root' }
+      )
+      assert_requested(stub)
+    end
+  end
+
+  context 'job_status' do
+    test 'fetches job status by ID' do
+      status_body = { 'status' => 'running' }
+      stub_request(:get, "#{PROXY_URL}/openbolt/job/test-123/status")
+        .to_return(status: 200, body: status_body.to_json, headers: { 'Content-Type' => 'application/json' })
+
+      result = @api.job_status(job_id: 'test-123')
+      assert_equal status_body, result
+    end
+  end
+
+  context 'job_result' do
+    test 'fetches job result by ID' do
+      result_body = { 'value' => { 'items' => [] }, 'log' => 'done' }
+      stub_request(:get, "#{PROXY_URL}/openbolt/job/test-123/result")
+        .to_return(status: 200, body: result_body.to_json, headers: { 'Content-Type' => 'application/json' })
+
+      result = @api.job_result(job_id: 'test-123')
+      assert_equal result_body, result
+    end
+  end
+
+  context 'delete_job_artifacts' do
+    test 'sends DELETE for job artifacts' do
+      stub_request(:delete, "#{PROXY_URL}/openbolt/job/test-123/artifacts")
+        .to_return(status: 200, body: '{"deleted": true}', headers: { 'Content-Type' => 'application/json' })
+
+      result = @api.delete_job_artifacts(job_id: 'test-123')
+      assert_equal({ 'deleted' => true }, result)
+    end
+  end
+
+  context 'connection errors' do
+    test 'raises on timeout' do
+      stub_request(:get, "#{PROXY_URL}/openbolt/tasks").to_timeout
+
+      assert_raises(RestClient::Exceptions::OpenTimeout) { @api.fetch_tasks }
+    end
+
+    test 'raises on connection refused' do
+      stub_request(:get, "#{PROXY_URL}/openbolt/tasks").to_raise(Errno::ECONNREFUSED)
+
+      assert_raises(Errno::ECONNREFUSED) { @api.fetch_tasks }
+    end
+  end
+end

data/test/unit/models/task_job_test.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class TaskJobTest < ForemanOpenbolt::PluginTestCase
+  context 'status helpers' do
+    test 'completed? returns true for completed statuses' do
+      ForemanOpenbolt::TaskJob::COMPLETED_STATUSES.each do |status|
+        job = FactoryBot.build(:task_job, status: status)
+        assert job.completed?, "Expected completed? to be true for status '#{status}'"
+      end
+    end
+
+    test 'completed? returns false for running statuses' do
+      ForemanOpenbolt::TaskJob::RUNNING_STATUSES.each do |status|
+        job = FactoryBot.build(:task_job, status: status)
+        assert_not job.completed?, "Expected completed? to be false for status '#{status}'"
+      end
+    end
+
+    test 'running? returns true for running statuses' do
+      ForemanOpenbolt::TaskJob::RUNNING_STATUSES.each do |status|
+        job = FactoryBot.build(:task_job, status: status)
+        assert job.running?, "Expected running? to be true for status '#{status}'"
+      end
+    end
+
+    test 'running? returns false for completed statuses' do
+      ForemanOpenbolt::TaskJob::COMPLETED_STATUSES.each do |status|
+        job = FactoryBot.build(:task_job, status: status)
+        assert_not job.running?, "Expected running? to be false for status '#{status}'"
+      end
+    end
+  end
+
+  context 'duration' do
+    # submitted_at could be nil for old rows that predate the column
+    test 'returns nil when submitted_at is nil' do
+      job = FactoryBot.build(:task_job, submitted_at: nil)
+      assert_nil job.duration
+    end
+
+    test 'returns nil when completed_at is nil' do
+      job = FactoryBot.build(:task_job, completed_at: nil)
+      assert_nil job.duration
+    end
+
+    test 'returns difference in seconds when both timestamps present' do
+      submitted = Time.current
+      completed = submitted + 45.seconds
+      job = FactoryBot.build(:task_job, submitted_at: submitted, completed_at: completed)
+      assert_in_delta 45.0, job.duration, 0.1
+    end
+  end
+
+  context 'target_count' do
+    test 'returns 0 when targets is nil' do
+      job = FactoryBot.build(:task_job)
+      job.targets = nil
+      assert_equal 0, job.target_count
+    end
+
+    test 'returns correct count for populated targets' do
+      job = FactoryBot.build(:task_job, targets: ['a.com', 'b.com', 'c.com'])
+      assert_equal 3, job.target_count
+    end
+  end
+
+  context 'formatted_targets' do
+    test 'returns empty string when targets is nil' do
+      job = FactoryBot.build(:task_job)
+      job.targets = nil
+      assert_equal '', job.formatted_targets
+    end
+
+    test 'returns CSV string for populated targets' do
+      job = FactoryBot.build(:task_job, targets: ['host1.com', 'host2.com'])
+      assert_equal 'host1.com, host2.com', job.formatted_targets
+    end
+  end
+
+  context 'validations' do
+    test 'valid with all required attributes' do
+      job = FactoryBot.build(:task_job)
+      assert job.valid?
+    end
+
+    test 'invalid without task_name' do
+      job = FactoryBot.build(:task_job, task_name: nil)
+      assert_not job.valid?
+      assert_includes job.errors[:task_name], "can't be blank"
+    end
+
+    test 'invalid without job_id' do
+      job = FactoryBot.build(:task_job, job_id: nil)
+      assert_not job.valid?
+      assert_includes job.errors[:job_id], "can't be blank"
+    end
+
+    test 'invalid with duplicate job_id' do
+      FactoryBot.create(:task_job, job_id: 'unique-id')
+      duplicate = FactoryBot.build(:task_job, job_id: 'unique-id')
+      assert_not duplicate.valid?
+      assert_includes duplicate.errors[:job_id], 'has already been taken'
+    end
+
+    test 'invalid with unknown status' do
+      job = FactoryBot.build(:task_job, status: 'unknown')
+      assert_not job.valid?
+      assert_includes job.errors[:status], 'is not included in the list'
+    end
+
+    test 'invalid without targets' do
+      job = FactoryBot.build(:task_job, targets: nil)
+      assert_not job.valid?
+      assert_includes job.errors[:targets], "can't be blank"
+    end
+  end
+
+  context 'scopes' do
+    setup do
+      @proxy = FactoryBot.create(:smart_proxy)
+      @pending_job = FactoryBot.create(:task_job, smart_proxy: @proxy, status: 'pending')
+      @running_job = FactoryBot.create(:task_job, smart_proxy: @proxy, status: 'running')
+      @success_job = FactoryBot.create(:task_job, :success, smart_proxy: @proxy)
+      @failure_job = FactoryBot.create(:task_job, :failure, smart_proxy: @proxy)
+    end
+
+    test 'running scope returns pending and running jobs' do
+      results = ForemanOpenbolt::TaskJob.running
+      assert_includes results, @pending_job
+      assert_includes results, @running_job
+      assert_not_includes results, @success_job
+      assert_not_includes results, @failure_job
+    end
+
+    test 'completed scope returns completed jobs' do
+      results = ForemanOpenbolt::TaskJob.completed
+      assert_includes results, @success_job
+      assert_includes results, @failure_job
+      assert_not_includes results, @pending_job
+      assert_not_includes results, @running_job
+    end
+
+    test 'recent scope orders by submitted_at' do
+      results = ForemanOpenbolt::TaskJob.recent
+      submitted_times = results.map(&:submitted_at)
+      assert_equal submitted_times, submitted_times.sort.reverse
+    end
+
+    test 'for_proxy scope filters by smart proxy' do
+      other_proxy = FactoryBot.create(:smart_proxy)
+      other_job = FactoryBot.create(:task_job, smart_proxy: other_proxy)
+
+      results = ForemanOpenbolt::TaskJob.for_proxy(@proxy)
+      assert_includes results, @pending_job
+      assert_not_includes results, other_job
+    end
+  end
+
+  context 'callbacks' do
+    test 'set_completed_at sets completed_at when status changes to completed' do
+      job = FactoryBot.create(:task_job, status: 'running')
+      assert_nil job.completed_at
+
+      job.update!(status: 'success')
+      assert_not_nil job.completed_at
+    end
+
+    test 'set_completed_at does not set completed_at when status stays running' do
+      job = FactoryBot.create(:task_job, status: 'running')
+      job.update!(task_name: 'different::task')
+      assert_nil job.completed_at
+    end
+
+    test 'cleanup_proxy_artifacts schedules Dynflow action when result is saved' do
+      job = FactoryBot.create(:task_job, status: 'success', completed_at: Time.current)
+      ForemanTasks.expects(:async_task).with(
+        ::Actions::ForemanOpenbolt::CleanupProxyArtifacts,
+        job.smart_proxy_id,
+        job.job_id
+      )
+
+      job.update!(result: { 'items' => [] })
+    end
+
+    test 'cleanup_proxy_artifacts does not schedule cleanup for running jobs' do
+      job = FactoryBot.create(:task_job, status: 'running')
+      ForemanTasks.expects(:async_task).never
+
+      job.update!(result: { 'items' => [] })
+    end
+
+    test 'cleanup_proxy_artifacts does not raise when scheduling fails' do
+      job = FactoryBot.create(:task_job, status: 'success', completed_at: Time.current)
+      ForemanTasks.expects(:async_task).raises(StandardError, 'Dynflow unavailable')
+
+      assert_nothing_raised do
+        job.update!(result: { 'items' => [] })
+      end
+      assert_equal({ 'items' => [] }, job.reload.result)
+    end
+  end
+
+  context 'create_from_execution!' do
+    test 'creates a task job with the correct attributes' do
+      proxy = FactoryBot.create(:smart_proxy)
+      job = ForemanOpenbolt::TaskJob.create_from_execution!(
+        proxy: proxy,
+        task_name: 'mymod::mytask',
+        task_description: 'Restart a service',
+        targets: ['web1.example.com'],
+        job_id: 'exec-123',
+        parameters: { 'service' => 'nginx' },
+        options: { 'transport' => 'ssh' }
+      )
+
+      assert_equal 'exec-123', job.job_id
+      assert_equal proxy, job.smart_proxy
+      assert_equal 'mymod::mytask', job.task_name
+      assert_equal 'Restart a service', job.task_description
+      assert_equal ['web1.example.com'], job.targets
+      assert_equal({ 'service' => 'nginx' }, job.task_parameters)
+      assert_equal({ 'transport' => 'ssh' }, job.openbolt_options)
+      assert_equal 'pending', job.status
+      assert_not_nil job.submitted_at
+    end
+  end
+
+  context 'update_from_proxy_result!' do
+    setup do
+      @job = FactoryBot.create(:task_job, status: 'running')
+      ForemanTasks.stubs(:async_task)
+    end
+
+    test 'updates status, command, result, and log from proxy result' do
+      @job.update_from_proxy_result!({
+        'status' => 'success',
+        'command' => 'bolt task run mymod::install',
+        'value' => { 'items' => [{ 'status' => 'success' }] },
+        'log' => 'Task completed successfully',
+      })
+
+      @job.reload
+      assert_equal 'success', @job.status
+      assert_equal 'bolt task run mymod::install', @job.command
+      assert_equal({ 'items' => [{ 'status' => 'success' }] }, @job.result)
+      assert_equal 'Task completed successfully', @job.log
+    end
+
+    test 'skips update for blank proxy result' do
+      original_status = @job.status
+      @job.update_from_proxy_result!(nil)
+      assert_equal original_status, @job.reload.status
+    end
+
+    test 'skips update for empty hash' do
+      original_status = @job.status
+      @job.update_from_proxy_result!({})
+      assert_equal original_status, @job.reload.status
+    end
+
+    test 'only updates fields present in the result' do
+      @job.update_from_proxy_result!({ 'status' => 'failure' })
+      @job.reload
+      assert_equal 'failure', @job.status
+      assert_nil @job.command
+      assert_nil @job.result
+    end
+
+    test 'sets result to nil when key is present with nil value' do
+      @job.update!(result: { 'items' => [{ 'status' => 'success' }] })
+      @job.update_from_proxy_result!({ 'status' => 'success', 'value' => nil })
+      @job.reload
+      assert_nil @job.result
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+// Mock for Foreman's I18n module. The real module depends on jed (gettext)
+// and Foreman's runtime locale configuration, which aren't available in
+// the plugin test environment. sprintf is mocked with minimal %s/%d
+// replacement so rendered strings are testable.
+export const translate = text => text;
+
+export const sprintf = (fmt, ...args) => {
+  let result = fmt;
+  args.forEach(arg => {
+    result = result.replace(/%[sd]/, arg);
+  });
+  return result;
+};
+
+export default { translate, sprintf };

data/webpack/__mocks__/foremanReact/components/ToastsList/index.js

@@ -0,0 +1,6 @@
+// Mock for Foreman's toast notification system. Uses jest.fn() so tests
+// can assert that error/success toasts are dispatched correctly.
+export const addToast = jest.fn(toast => ({
+  type: 'ADD_TOAST',
+  payload: toast,
+}));

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

@@ -0,0 +1,11 @@
+// Mock for Foreman's API wrapper. Uses jest.fn() so tests can stub
+// responses with mockResolvedValue/mockRejectedValue and assert calls.
+export const API = {
+  get: jest.fn(),
+  post: jest.fn(),
+  put: jest.fn(),
+  delete: jest.fn(),
+  patch: jest.fn(),
+};
+
+export default API;

data/webpack/src/Components/LaunchTask/FieldTable.js

@@ -37,12 +37,13 @@ const FieldTable = ({ rows }) => {
       isStickyHeader
       gridBreakPoint="grid-md"
       style={{ wordBreak: 'break-word' }}
+      aria-label={__('Parameters and options')}
     >
       <Thead>
         <Tr>
           <Th aria-label="Row expand control" />
-          <Th width={25}>Name</Th>
-          <Th width={75}>Value</Th>
+          <Th width={25}>{__('Name')}</Th>
+          <Th width={75}>{__('Value')}</Th>
         </Tr>
       </Thead>
 
@@ -74,7 +75,7 @@ const FieldTable = ({ rows }) => {
                     onToggle: () => toggle(rowKey),
                   }}
                 />
-                <Td dataLabel="Name">
+                <Td dataLabel={__('Name')}>
                   <span className="pf-v5-u-font-family-monospace">{name}</span>
                   {required && (
                     <span
@@ -82,13 +83,15 @@ const FieldTable = ({ rows }) => {
                         color: 'red',
                         marginLeft: '0.25rem',
                       }}
-                      title="Required"
+                      title={__('Required')}
+                      role="img"
+                      aria-label={__('Required')}
                     >
                       *
                     </span>
                   )}
                 </Td>
-                <Td dataLabel="Value">{valueCell}</Td>
+                <Td dataLabel={__('Value')}>{valueCell}</Td>
               </Tr>
 
               {(type || description) && (