foreman_openbolt 1.1.0 → 1.1.1

data/test/unit/controllers/task_controller_test.rb

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class TaskControllerTest < ActionController::TestCase
+  tests ForemanOpenbolt::TaskController
+
+  setup do
+    @routes = ForemanOpenbolt::Engine.routes
+    @proxy = FactoryBot.create(:smart_proxy)
+    @session = set_session_user
+    WebMock.reset!
+  end
+
+  teardown do
+    WebMock.reset!
+  end
+
+  context 'fetch_tasks' do
+    test 'returns tasks from proxy as JSON' 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' })
+
+      get :fetch_tasks, params: { proxy_id: @proxy.id }, session: @session
+      assert_response :success
+      assert_equal tasks, JSON.parse(response.body)
+    end
+
+    test 'returns error when proxy_id is missing' do
+      get :fetch_tasks, session: @session
+      assert_response :bad_request
+      body = JSON.parse(response.body)
+      assert_match(/Smart Proxy ID is required/, body['error'])
+    end
+
+    test 'returns error when proxy not found' do
+      get :fetch_tasks, params: { proxy_id: -1 }, session: @session
+      assert_response :not_found
+    end
+
+    test 'returns internal_server_error when proxy is unreachable' do
+      stub_request(:get, "#{@proxy.url}/openbolt/tasks").to_timeout
+
+      get :fetch_tasks, params: { proxy_id: @proxy.id }, session: @session
+      assert_response :internal_server_error
+    end
+  end
+
+  context 'reload_tasks' do
+    test 'returns reloaded tasks from proxy' do
+      tasks = { 'new::task' => {} }
+      stub_request(:get, "#{@proxy.url}/openbolt/tasks/reload")
+        .to_return(status: 200, body: tasks.to_json, headers: { 'Content-Type' => 'application/json' })
+
+      get :reload_tasks, params: { proxy_id: @proxy.id }, session: @session
+      assert_response :success
+      assert_equal tasks, JSON.parse(response.body)
+    end
+  end
+
+  context 'launch_task' do
+    setup 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' })
+      stub_request(:post, "#{@proxy.url}/openbolt/launch/task")
+        .to_return(status: 200, body: { 'id' => 'launched-job-1' }.to_json,
+          headers: { 'Content-Type' => 'application/json' })
+      ForemanTasks.stubs(:async_task)
+    end
+
+    test 'launches task and returns job_id' do
+      post :launch_task, params: {
+        proxy_id: @proxy.id,
+        task_name: 'mymod::install',
+        targets: 'host1.example.com',
+        params: { 'name' => 'nginx' },
+        options: { 'transport' => 'ssh' },
+      }, session: @session
+
+      assert_response :success
+      body = JSON.parse(response.body)
+      assert_equal 'launched-job-1', body['job_id']
+    end
+
+    test 'schedules polling after creating task' do
+      ForemanTasks.expects(:async_task).with(
+        Actions::ForemanOpenbolt::PollTaskStatus,
+        'launched-job-1',
+        @proxy.id
+      )
+
+      post :launch_task, params: {
+        proxy_id: @proxy.id,
+        task_name: 'mymod::install',
+        targets: 'host1.example.com',
+      }, session: @session
+
+      assert_response :success
+    end
+
+    test 'creates a TaskJob record' do
+      assert_difference('ForemanOpenbolt::TaskJob.count', 1) do
+        post :launch_task, params: {
+          proxy_id: @proxy.id,
+          task_name: 'mymod::install',
+          targets: 'host1.example.com,host2.example.com',
+        }, session: @session
+      end
+
+      job = ForemanOpenbolt::TaskJob.last
+      assert_equal 'mymod::install', job.task_name
+      assert_equal %w[host1.example.com host2.example.com], job.targets
+      assert_equal 'pending', job.status
+    end
+
+    test 'returns error when task_name is missing' do
+      post :launch_task, params: { proxy_id: @proxy.id, targets: 'host1' }, session: @session
+      assert_response :bad_request
+      assert_match(/task_name/, JSON.parse(response.body)['error'])
+    end
+
+    test 'returns error when targets is missing' do
+      post :launch_task, params: { proxy_id: @proxy.id, task_name: 'test::task' }, session: @session
+      assert_response :bad_request
+      assert_match(/targets/, JSON.parse(response.body)['error'])
+    end
+
+    test 'returns error when proxy returns error in response' do
+      stub_request(:post, "#{@proxy.url}/openbolt/launch/task")
+        .to_return(status: 200, body: { 'error' => 'Task not found' }.to_json,
+          headers: { 'Content-Type' => 'application/json' })
+
+      post :launch_task, params: {
+        proxy_id: @proxy.id,
+        task_name: 'missing::task',
+        targets: 'host1',
+      }, session: @session
+      assert_response :bad_request
+      assert_match(/Task execution failed/, JSON.parse(response.body)['error'])
+    end
+
+    test 'returns error when proxy returns no job ID' do
+      stub_request(:post, "#{@proxy.url}/openbolt/launch/task")
+        .to_return(status: 200, body: { 'status' => 'ok' }.to_json,
+          headers: { 'Content-Type' => 'application/json' })
+
+      post :launch_task, params: {
+        proxy_id: @proxy.id,
+        task_name: 'test::task',
+        targets: 'host1',
+      }, session: @session
+      assert_response :bad_request
+      assert_match(/No job ID returned/, JSON.parse(response.body)['error'])
+    end
+  end
+
+  context 'job_status' do
+    test 'returns serialized task job' do
+      job = FactoryBot.create(:task_job, :running, smart_proxy: @proxy)
+
+      get :job_status, params: { job_id: job.job_id }, session: @session
+      assert_response :success
+
+      body = JSON.parse(response.body)
+      assert_equal 'running', body['status']
+      assert_equal job.task_name, body['task_name']
+      assert_equal job.targets, body['targets']
+      assert_equal @proxy.id, body['smart_proxy']['id']
+      assert_equal @proxy.name, body['smart_proxy']['name']
+    end
+
+    test 'returns error when job_id is missing' do
+      get :job_status, session: @session
+      assert_response :bad_request
+    end
+
+    test 'returns not_found when job does not exist' do
+      get :job_status, params: { job_id: 'nonexistent' }, session: @session
+      assert_response :not_found
+    end
+  end
+
+  context 'job_result' do
+    test 'returns result and log for completed job' do
+      ForemanTasks.stubs(:async_task)
+      job = FactoryBot.create(:task_job, :success, smart_proxy: @proxy)
+
+      get :job_result, params: { job_id: job.job_id }, session: @session
+      assert_response :success
+
+      body = JSON.parse(response.body)
+      assert_equal 'success', body['status']
+      assert_equal job.result, body['value']
+      assert_equal job.log, body['log']
+      assert_equal job.command, body['command']
+    end
+
+    test 'returns not_found when job does not exist' do
+      get :job_result, params: { job_id: 'nonexistent' }, session: @session
+      assert_response :not_found
+    end
+  end
+
+  context 'launch_task with encrypted options' do
+    setup 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' })
+      stub_request(:post, "#{@proxy.url}/openbolt/launch/task")
+        .to_return(status: 200, body: { 'id' => 'encrypted-job-1' }.to_json,
+          headers: { 'Content-Type' => 'application/json' })
+      ForemanTasks.stubs(:async_task)
+    end
+
+    test 'replaces encrypted placeholder with real setting value before sending to proxy' do
+      Setting['openbolt_password'] = 'real-secret-password'
+
+      post :launch_task, params: {
+        proxy_id: @proxy.id,
+        task_name: 'mymod::install',
+        targets: 'host1.example.com',
+        options: { 'password' => '[Use saved encrypted default]', 'transport' => 'ssh' },
+      }, session: @session
+
+      assert_response :success
+
+      # Verify the real value was sent to the proxy (not the placeholder)
+      proxy_request = WebMock::RequestRegistry.instance
+                                              .requested_signatures
+                                              .hash
+                                              .keys
+                                              .find { |sig| sig.uri.path == '/openbolt/launch/task' }
+      sent_body = JSON.parse(proxy_request.body)
+      assert_equal 'real-secret-password', sent_body['options']['password']
+    end
+
+    test 'scrubs encrypted options before storing in database' do
+      Setting['openbolt_password'] = 'real-secret-password'
+
+      post :launch_task, params: {
+        proxy_id: @proxy.id,
+        task_name: 'mymod::install',
+        targets: 'host1.example.com',
+        options: { 'password' => '[Use saved encrypted default]', 'transport' => 'ssh' },
+      }, session: @session
+
+      assert_response :success
+      job = ForemanOpenbolt::TaskJob.find_by(job_id: 'encrypted-job-1')
+      assert_equal '*****', job.openbolt_options['password']
+      assert_equal 'ssh', job.openbolt_options['transport']
+    end
+
+    test 'returns error when encrypted placeholder used for nonexistent setting' do
+      post :launch_task, params: {
+        proxy_id: @proxy.id,
+        task_name: 'mymod::install',
+        targets: 'host1.example.com',
+        options: { 'nonexistent-option' => '[Use saved encrypted default]' },
+      }, session: @session
+
+      assert_response :bad_request
+      assert_match(/No saved value for encrypted option/, JSON.parse(response.body)['error'])
+    end
+
+    test 'passes non-encrypted options through unchanged' do
+      post :launch_task, params: {
+        proxy_id: @proxy.id,
+        task_name: 'mymod::install',
+        targets: 'host1.example.com',
+        options: { 'transport' => 'ssh', 'user' => 'admin' },
+      }, session: @session
+
+      assert_response :success
+      job = ForemanOpenbolt::TaskJob.find_by(job_id: 'encrypted-job-1')
+      assert_equal 'ssh', job.openbolt_options['transport']
+      assert_equal 'admin', job.openbolt_options['user']
+    end
+  end
+
+  context 'fetch_openbolt_options with settings defaults' do
+    test 'merges Foreman setting defaults into proxy options' do
+      Setting['openbolt_transport'] = 'winrm'
+      Setting['openbolt_user'] = 'admin'
+
+      proxy_options = {
+        'transport' => { 'type' => %w[ssh winrm] },
+        'user' => { 'type' => 'string' },
+        'verbose' => { 'type' => 'boolean' },
+      }
+      stub_request(:get, "#{@proxy.url}/openbolt/tasks/options")
+        .to_return(status: 200, body: proxy_options.to_json, headers: { 'Content-Type' => 'application/json' })
+
+      get :fetch_openbolt_options, params: { proxy_id: @proxy.id }, session: @session
+      assert_response :success
+
+      body = JSON.parse(response.body)
+      assert_equal 'winrm', body['transport']['default']
+      assert_equal 'admin', body['user']['default']
+      assert_equal false, body['verbose']['default']
+    end
+
+    test 'shows encrypted placeholder instead of real value for encrypted settings' do
+      Setting['openbolt_password'] = 'secret-value'
+
+      proxy_options = {
+        'password' => { 'type' => 'string', 'sensitive' => true },
+      }
+      stub_request(:get, "#{@proxy.url}/openbolt/tasks/options")
+        .to_return(status: 200, body: proxy_options.to_json, headers: { 'Content-Type' => 'application/json' })
+
+      get :fetch_openbolt_options, params: { proxy_id: @proxy.id }, session: @session
+      assert_response :success
+
+      body = JSON.parse(response.body)
+      assert_equal '[Use saved encrypted default]', body['password']['default']
+    end
+  end
+
+  context 'fetch_task_history' do
+    test 'returns paginated task history' do
+      3.times { FactoryBot.create(:task_job, smart_proxy: @proxy) }
+
+      get :fetch_task_history, params: { page: 1, per_page: 2 }, session: @session
+      assert_response :success
+
+      body = JSON.parse(response.body)
+      assert_equal 2, body['results'].length
+      assert_equal 3, body['total']
+      assert_equal 1, body['page']
+      assert_equal 2, body['per_page']
+    end
+
+    test 'caps per_page at 100' do
+      get :fetch_task_history, params: { per_page: 200 }, session: @session
+      assert_response :success
+
+      body = JSON.parse(response.body)
+      assert_equal 100, body['per_page']
+    end
+
+    test 'defaults per_page to 20' do
+      get :fetch_task_history, session: @session
+      assert_response :success
+
+      body = JSON.parse(response.body)
+      assert_equal 20, body['per_page']
+    end
+  end
+end

data/test/unit/docker/Dockerfile

@@ -0,0 +1,47 @@
+# Base test image: Foreman + system deps on Rocky Linux 9.
+# This image is stable for a given Foreman version and does not
+# depend on any foreman_openbolt code. All plugin wiring happens
+# at runtime via the rake test:up task.
+#
+# Build:
+#   FOREMAN_BRANCH=3.18-stable docker compose -f test/unit/docker/docker-compose.yml build test
+
+FROM rockylinux:9
+
+# System packages -- cached across all Foreman versions.
+RUN dnf module enable -y nodejs:22 postgresql:16 && \
+    dnf install -y \
+      ruby ruby-devel rubygem-bundler \
+      gcc gcc-c++ make \
+      postgresql-devel postgresql \
+      libffi-devel \
+      nodejs npm \
+      git-core \
+      redhat-rpm-config && \
+    dnf clean all
+
+ARG FOREMAN_BRANCH=3.18-stable
+
+# Clone Foreman at the specified branch.
+RUN git init /opt/foreman
+
+WORKDIR /opt/foreman
+
+RUN git remote add origin https://github.com/theforeman/foreman.git && \
+    git fetch --depth=1 origin ${FOREMAN_BRANCH} && \
+    git checkout FETCH_HEAD
+
+# Configure database for the test container.
+RUN printf "test:\n  adapter: postgresql\n  host: db\n  port: 5432\n  username: foreman\n  password: foreman\n  database: foreman_test\n  encoding: utf8\n  pool: 5\n" \
+      > config/database.yml
+
+# Install Foreman's own gems (without the plugin). This is the
+# expensive layer but only changes when the Foreman version changes.
+ENV BUNDLE_WITHOUT="release console journald libvirt ec2 openstack vmware telemetry"
+ENV BUNDLE_PATH="/opt/bundle"
+RUN bundle install --jobs=4
+
+COPY test/unit/docker/entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+
+ENTRYPOINT ["/entrypoint.sh"]

data/test/unit/docker/docker-compose.yml

@@ -0,0 +1,33 @@
+name: foreman-openbolt-unit
+
+services:
+  db:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: foreman
+      POSTGRES_PASSWORD: foreman
+      POSTGRES_DB: foreman_test
+    tmpfs: /var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U foreman"]
+      interval: 2s
+      timeout: 5s
+      retries: 10
+
+  test:
+    image: foreman-openbolt-test:${FOREMAN_BRANCH:-3.18-stable}
+    build:
+      context: ../../..
+      dockerfile: test/unit/docker/Dockerfile
+      args:
+        FOREMAN_BRANCH: ${FOREMAN_BRANCH:-3.18-stable}
+    depends_on:
+      db:
+        condition: service_healthy
+    environment:
+      RAILS_ENV: test
+      DATABASE_URL: postgresql://foreman:foreman@db:5432/foreman_test
+    volumes:
+      - ../../..:/opt/foreman_openbolt
+    working_dir: /opt/foreman
+    command: ["tail", "-f", "/dev/null"]

data/test/unit/docker/entrypoint.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+set -e
+
+exec "$@"

data/test/unit/factories/foreman_openbolt_factories.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :task_job, class: 'ForemanOpenbolt::TaskJob' do
+    sequence(:job_id) { |n| "test-job-#{n}" }
+    association :smart_proxy
+    task_name { 'mymod::install' }
+    task_description { 'Install a package on the target host' }
+    status { 'pending' }
+    targets { ['host1.example.com', 'host2.example.com'] }
+    submitted_at { Time.current }
+    task_parameters { { 'name' => 'nginx' } }
+    openbolt_options { { 'transport' => 'ssh' } }
+
+    trait :running do
+      status { 'running' }
+    end
+
+    trait :success do
+      status { 'success' }
+      completed_at { Time.current }
+      result { { 'items' => [{ 'target' => 'host1.example.com', 'status' => 'success' }] } }
+      log { 'Started: task mymod::install\nFinished: success' }
+      command { 'bolt task run mymod::install --targets host1.example.com' }
+    end
+
+    trait :failure do
+      status { 'failure' }
+      completed_at { Time.current }
+      result { { 'items' => [{ 'target' => 'host1.example.com', 'status' => 'failure' }] } }
+      log { 'Started: task mymod::install\nFinished: failure' }
+    end
+
+    trait :exception do
+      status { 'exception' }
+      completed_at { Time.current }
+    end
+  end
+end

data/test/unit/lib/actions/cleanup_proxy_artifacts_test.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class CleanupProxyArtifactsTest < ForemanOpenbolt::PluginTestCase
+  include Dynflow::Testing
+
+  context 'plan' do
+    test 'stores proxy_id and job_id in input' do
+      action = create_and_plan_action(Actions::ForemanOpenbolt::CleanupProxyArtifacts, 42, 'job-123')
+      assert_equal 42, action.input[:proxy_id]
+      assert_equal 'job-123', action.input[:job_id]
+    end
+  end
+
+  context 'rescue_strategy' do
+    test 'uses Skip rescue strategy' do
+      action = create_action(Actions::ForemanOpenbolt::CleanupProxyArtifacts)
+      assert_equal Dynflow::Action::Rescue::Skip, action.rescue_strategy
+    end
+  end
+
+  context 'run' do
+    test 'calls delete_job_artifacts when proxy exists' do
+      proxy = FactoryBot.create(:smart_proxy)
+      stub = stub_request(:delete, "#{proxy.url}/openbolt/job/job-456/artifacts")
+             .to_return(status: 200, body: '{"deleted": true}', headers: { 'Content-Type' => 'application/json' })
+
+      action = create_and_plan_action(Actions::ForemanOpenbolt::CleanupProxyArtifacts, proxy.id, 'job-456')
+      run_action(action)
+
+      assert_requested(stub)
+    end
+
+    test 'does not call API when proxy not found' do
+      stub = stub_request(:delete, %r{openbolt/job})
+      action = create_and_plan_action(Actions::ForemanOpenbolt::CleanupProxyArtifacts, -1, 'job-456')
+      run_action(action)
+      assert_not_requested(stub)
+    end
+
+    test 'does not raise when API call fails' do
+      proxy = FactoryBot.create(:smart_proxy)
+      stub_request(:delete, "#{proxy.url}/openbolt/job/job-456/artifacts")
+        .to_return(status: 500, body: 'Internal Server Error')
+
+      action = create_and_plan_action(Actions::ForemanOpenbolt::CleanupProxyArtifacts, proxy.id, 'job-456')
+      assert_nothing_raised { run_action(action) }
+    end
+  end
+end

data/test/unit/lib/actions/poll_task_status_test.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class PollTaskStatusTest < ForemanOpenbolt::PluginTestCase
+  include Dynflow::Testing
+
+  context 'extract_proxy_error' do
+    setup do
+      @action = create_action(Actions::ForemanOpenbolt::PollTaskStatus)
+    end
+
+    test 'returns nil for nil response' do
+      assert_nil @action.extract_proxy_error(nil)
+    end
+
+    test 'returns nil when no error key' do
+      assert_nil @action.extract_proxy_error({ 'status' => 'running' })
+    end
+
+    test 'returns nil for empty error string' do
+      assert_nil @action.extract_proxy_error({ 'error' => '' })
+    end
+
+    test 'returns string error directly' do
+      assert_equal 'something broke', @action.extract_proxy_error({ 'error' => 'something broke' })
+    end
+
+    test 'returns message from hash error' do
+      assert_equal 'detailed error', @action.extract_proxy_error({ 'error' => { 'message' => 'detailed error' } })
+    end
+
+    test 'returns stringified hash when no message key' do
+      error_hash = { 'code' => 500 }
+      result = @action.extract_proxy_error({ 'error' => error_hash })
+      assert_equal error_hash.to_s, result
+    end
+  end
+
+  context 'plan' do
+    test 'stores job_id and proxy_id in input' do
+      action = create_and_plan_action(Actions::ForemanOpenbolt::PollTaskStatus, 'job-123', 42)
+      assert_equal 'job-123', action.input[:job_id]
+      assert_equal 42, action.input[:proxy_id]
+    end
+  end
+
+  context 'rescue_strategy' do
+    test 'uses Skip rescue strategy' do
+      action = create_action(Actions::ForemanOpenbolt::PollTaskStatus)
+      assert_equal Dynflow::Action::Rescue::Skip, action.rescue_strategy
+    end
+  end
+
+  context 'poll_and_reschedule' do
+    setup do
+      @proxy = FactoryBot.create(:smart_proxy)
+      @job = FactoryBot.create(:task_job, :running, smart_proxy: @proxy)
+    end
+
+    test 'polls proxy and keeps status when unchanged' do
+      status_stub = stub_request(:get, "#{@proxy.url}/openbolt/job/#{@job.job_id}/status")
+                    .to_return(status: 200, body: { 'status' => 'running' }.to_json,
+                      headers: { 'Content-Type' => 'application/json' })
+
+      action = create_and_plan_action(Actions::ForemanOpenbolt::PollTaskStatus, @job.job_id, @proxy.id)
+      run_action(action)
+
+      assert_requested(status_stub)
+      assert_equal 'running', @job.reload.status
+    end
+
+    test 'fetches result when job completes' do
+      stub_request(:get, "#{@proxy.url}/openbolt/job/#{@job.job_id}/status")
+        .to_return(status: 200, body: { 'status' => 'success' }.to_json,
+          headers: { 'Content-Type' => 'application/json' })
+
+      result_body = { 'status' => 'success', 'value' => { 'items' => [] }, 'log' => 'done',
+                      'command' => 'bolt task run test' }
+      stub_request(:get, "#{@proxy.url}/openbolt/job/#{@job.job_id}/result")
+        .to_return(status: 200, body: result_body.to_json,
+          headers: { 'Content-Type' => 'application/json' })
+
+      ForemanTasks.stubs(:async_task)
+      action = create_and_plan_action(Actions::ForemanOpenbolt::PollTaskStatus, @job.job_id, @proxy.id)
+      run_action(action)
+
+      @job.reload
+      assert_equal 'success', @job.status
+      assert_equal({ 'items' => [] }, @job.result)
+      assert_equal 'done', @job.log
+    end
+
+    test 'finishes cleanly when task job not found' do
+      action = create_and_plan_action(Actions::ForemanOpenbolt::PollTaskStatus, 'nonexistent-id', @proxy.id)
+      assert_nothing_raised { run_action(action) }
+    end
+
+    test 'marks exception when proxy not found' do
+      action = create_and_plan_action(Actions::ForemanOpenbolt::PollTaskStatus, @job.job_id, -1)
+      run_action(action)
+
+      assert_equal 'exception', @job.reload.status
+    end
+
+    test 'marks exception immediately on proxy application error' do
+      status_stub = stub_request(:get, "#{@proxy.url}/openbolt/job/#{@job.job_id}/status")
+                    .to_return(status: 200, body: { 'error' => { 'message' => 'Job not found: test-job' } }.to_json,
+                      headers: { 'Content-Type' => 'application/json' })
+
+      action = create_and_plan_action(Actions::ForemanOpenbolt::PollTaskStatus, @job.job_id, @proxy.id)
+      run_action(action)
+
+      assert_requested(status_stub)
+      assert_equal 'exception', @job.reload.status
+    end
+
+    test 'marks exception immediately when proxy response has no status' do
+      stub_request(:get, "#{@proxy.url}/openbolt/job/#{@job.job_id}/status")
+        .to_return(status: 200, body: { 'unexpected' => 'data' }.to_json,
+          headers: { 'Content-Type' => 'application/json' })
+
+      action = create_and_plan_action(Actions::ForemanOpenbolt::PollTaskStatus, @job.job_id, @proxy.id)
+      run_action(action)
+
+      assert_equal 'exception', @job.reload.status
+    end
+
+    test 'marks job as exception after exhausting retry limit' do
+      stub_request(:get, "#{@proxy.url}/openbolt/job/#{@job.job_id}/status")
+        .to_return(status: 500, body: 'Internal Server Error')
+
+      action = create_and_plan_action(Actions::ForemanOpenbolt::PollTaskStatus, @job.job_id, @proxy.id)
+      # Set retry count to just above the limit so the next error triggers exhaustion
+      action.input[:retry_count] = Actions::ForemanOpenbolt::PollTaskStatus::RETRY_LIMIT
+      run_action(action)
+
+      assert_equal 'exception', @job.reload.status
+    end
+  end
+end