foreman_remote_execution 14.0.0 → 14.1.0

data/test/functional/api/v2/job_templates_controller_test.rb

@@ -1,110 +0,0 @@
-require 'test_plugin_helper'
-
-module Api
-  module V2
-    class JobTemplatesControllerTest < ActionController::TestCase
-      setup do
-        @template = FactoryBot.create :job_template
-      end
-
-      test 'should get index' do
-        get :index
-        templates = ActiveSupport::JSON.decode(@response.body)
-        assert_not templates.empty?, 'Should response with template'
-        assert_response :success
-      end
-
-      test 'should get templates of give organization' do
-        @organization = FactoryBot.create(:organization)
-        @template.organizations << @organization
-        @template.save!
-        get :index, params: { :organization_id => @organization.id }
-        templates = ActiveSupport::JSON.decode(@response.body)
-        assert_not templates.empty?, 'Should respond with template'
-        assert_response :success
-      end
-
-      test 'should get template detail' do
-        get :show, params: { :id => @template.to_param }
-        assert_response :success
-        template = ActiveSupport::JSON.decode(@response.body)
-        assert_not template.empty?
-        assert_equal template['name'], @template.name
-        assert_not_nil template['created_at']
-        assert_not_nil template['updated_at']
-      end
-
-      test 'should create valid' do
-        JobTemplate.any_instance.stubs(:valid?).returns(true)
-        valid_attrs = { :template => 'This is a test template', :name => 'RandomName', :provider_type => 'ssh' }
-        post :create, params: { :job_template => valid_attrs }
-        template = ActiveSupport::JSON.decode(@response.body)
-        assert_equal template['name'], 'RandomName'
-        assert_response :success
-      end
-
-      test 'should not create invalid' do
-        post :create
-        assert_response :unprocessable_entity
-      end
-
-      test 'should update valid' do
-        JobTemplate.any_instance.stubs(:valid?).returns(true)
-        put :update, params: { :id => @template.to_param, :job_template => { :template => 'blah' } }
-        assert_response :ok
-      end
-
-      test 'should not update invalid' do
-        put :update, params: { :id => @template.to_param, :job_template => { :name => '' } }
-        assert_response :unprocessable_entity
-      end
-
-      test 'should update effective user' do
-        template = { name: @template.name, job_category: @template.job_category,
-                     template: @template.template, provider_type: 'SSH',
-                     effective_user_attributes: {
-                       value: 'nobody',
-                       overridable: true,
-                       current_user: false,
-                     } }
-        put :update, params: { id: @template.to_param, job_template: template }
-        assert_response :ok
-      end
-
-      test 'should destroy' do
-        delete :destroy, params: { :id => @template.to_param }
-        assert_response :ok
-        assert_not JobTemplate.exists?(@template.id)
-      end
-
-      test 'should clone template' do
-        post :clone, params: { :id => @template.to_param, :job_template => {:name => 'MyClone'} }
-        assert_response :success
-        template = ActiveSupport::JSON.decode(@response.body)
-        assert_equal(template['name'], 'MyClone')
-        assert_equal(template['template'], @template.template)
-      end
-
-      test 'clone name should not be blank' do
-        post :clone, params: { :id => @template.to_param, :job_template => {:name => ''} }
-        assert_response :unprocessable_entity
-      end
-
-      test 'should export template' do
-        get :export, params: { :id => @template.to_param }
-        User.current = users(:admin)
-        assert_equal @response.body, @template.to_erb
-        assert_response :success
-      end
-
-      test 'should import template' do
-        new_name = @template.name = "#{@template.name}_renamed"
-        erb_data = @template.to_erb
-        post :import, params: { :template => erb_data }
-        assert_response :success
-        assert JobTemplate.unscoped.find_by(name: new_name)
-      end
-    end
-
-  end
-end

data/test/functional/api/v2/registration_controller_test.rb

@@ -1,73 +0,0 @@
-require 'test_plugin_helper'
-
-module Api
-  module V2
-    # Tests for the extra methods to play roles on a Host
-    class RegistrationControllerTest < ActionController::TestCase
-      describe 'host registration' do
-        let(:organization) { FactoryBot.create(:organization) }
-        let(:tax_location) { FactoryBot.create(:location) }
-        let(:template) do
-          FactoryBot.create(
-            :provisioning_template,
-            template_kind: template_kinds(:host_init_config),
-            template: 'template content <%= @host.name %>',
-            locations: [tax_location],
-            organizations: [organization]
-          )
-        end
-        let(:os) do
-          FactoryBot.create(
-            :operatingsystem,
-            :with_associations,
-            family: 'Redhat',
-            provisioning_templates: [
-              template,
-            ]
-          )
-        end
-
-        let(:host_params) do
-          { host: { name: 'centos-test.example.com',
-                    managed: false, build: false,
-                    organization_id: organization.id,
-                    location_id: tax_location.id,
-                    operatingsystem_id: os.id } }
-        end
-
-        describe 'remote_execution_interface' do
-          setup do
-            Setting[:default_host_init_config_template] = template.name
-            @host = Host.create(host_params[:host])
-            @interface0 = FactoryBot.create(:nic_managed, host: @host, identifier: 'dummy0', execution: false)
-          end
-
-          test 'with existing interface' do
-            params = host_params.merge(remote_execution_interface: @interface0.identifier)
-
-            post :host, params: params, session: set_session_user
-            assert_response :success
-            assert @interface0.reload.execution
-          end
-
-          test 'with not-existing interface' do
-            params = host_params.merge(remote_execution_interface: 'dummy999')
-
-            post :host, params: params, session: set_session_user
-            assert_response :not_found
-          end
-
-          test 'with multiple interfaces' do
-            interface1 = FactoryBot.create(:nic_managed, host: @host, identifier: 'dummy1', execution: false)
-            params = host_params.merge(remote_execution_interface: interface1.identifier)
-
-            post :host, params: params, session: set_session_user
-            assert_response :success
-            refute @interface0.reload.execution
-            assert interface1.reload.execution
-          end
-        end
-      end
-    end
-  end
-end

data/test/functional/api/v2/remote_execution_features_controller_test.rb

@@ -1,34 +0,0 @@
-require 'test_plugin_helper'
-
-module Api
-  module V2
-    class RemoteExecutionFeaturesControllerTest < ActionController::TestCase
-      setup do
-        @remote_execution_feature = RemoteExecutionFeature.register(:my_awesome_feature, 'My awesome feature',
-          :description => 'You will not believe what it does',
-          :provided_inputs => ['awesomeness_level'])
-        @template = FactoryBot.create(:job_template, :with_input)
-      end
-
-      test 'should get index' do
-        get :index
-        remote_execution_features = ActiveSupport::JSON.decode(@response.body)
-        assert_not remote_execution_features.empty?, 'Should respond with input sets'
-        assert_response :success
-      end
-
-      test 'should get input set detail' do
-        get :show, params: { :id => @remote_execution_feature.to_param }
-        assert_response :success
-        remote_execution_feature = ActiveSupport::JSON.decode(@response.body)
-        assert_not remote_execution_feature.empty?
-        assert_equal remote_execution_feature['name'], @remote_execution_feature.name
-      end
-
-      test 'should update valid' do
-        put :update, params: { :id => @remote_execution_feature.to_param, :job_template_id => @template.id }
-        assert_response :ok
-      end
-    end
-  end
-end

data/test/functional/api/v2/template_invocations_controller_test.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_plugin_helper'
-
-module Api
-  module V2
-    class TemplateInvocationsControllerTest < ActionController::TestCase
-      setup do
-        @job = FactoryBot.create(:job_invocation, :with_template, :with_task)
-        @template_invocation = @job.template_invocations.first
-      end
-
-      test 'should get template invocations belonging to job invocation' do
-        get :template_invocations, params: { :id => @job.id }
-        invocations = ActiveSupport::JSON.decode(@response.body)
-        assert_equal @job.template_invocations.count, invocations['results'].count
-        assert_equal @job.template_invocations.count, invocations['total']
-
-        expected_result = {
-          'id'                   => @template_invocation.id,
-          'host_id'              => @template_invocation.host_id,
-          'host_name'            => @template_invocation.host.name,
-          'template_id'          => @template_invocation.template_id,
-          'effective_user'       => @template_invocation.effective_user,
-          'job_invocation_id'    => @job.id,
-          'run_host_job_task_id' => @template_invocation.run_host_job_task_id,
-        }
-        assert_equal [expected_result], invocations['results']
-        assert_response :success
-      end
-    end
-  end
-end

data/test/functional/cockpit_controller_test.rb

@@ -1,16 +0,0 @@
-require 'test_plugin_helper'
-
-class CockpitControllerTest < ActionController::TestCase
-  def setup
-    as_admin do
-      @host = FactoryBot.create(:host)
-    end
-  end
-
-  test "should get host_ssh_params" do
-    get :host_ssh_params, params: { id: @host.id }, session: set_session_user
-    assert_response :success
-    response = ActiveSupport::JSON.decode(@response.body)
-    assert response.key?('ssh_user'), 'ssh_params response must include ssh_user'
-  end
-end

data/test/functional/job_invocations_controller_test.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_plugin_helper'
-require_relative '../support/remote_execution_helper'
-
-class JobInvocationsControllerTest < ActionController::TestCase
-  test 'should parse inputs coming from the URL params' do
-    template = FactoryBot.create(:job_template, :with_input)
-    feature = FactoryBot.create(:remote_execution_feature,
-      :job_template => template)
-    params = {
-      feature: feature.label,
-      inputs: { template.template_inputs.first.name => 'foobar' },
-    }
-
-    get :new, params: params, session: set_session_user
-    template_invocation_params = [
-      {
-        'input_values' =>
-        [
-          {
-            'value' => 'foobar',
-            'template_input_id' => template.template_inputs.first.id,
-          },
-        ],
-        'template_id' => template.id,
-      },
-    ]
-    assert_equal(template_invocation_params,
-      assigns(:composer).params['template_invocations'])
-  end
-
-  test 'should allow no inputs' do
-    template = FactoryBot.create(:job_template)
-    feature = FactoryBot.create(:remote_execution_feature,
-      :job_template => template)
-    params = {
-      feature: feature.label,
-    }
-    get :new, params: params, session: set_session_user
-    template_invocation_params = [
-      {
-        'template_id' => template.id,
-        'input_values' => {},
-      },
-    ]
-    assert_equal(template_invocation_params,
-      assigns(:composer).params['template_invocations'])
-  end
-
-  test 'new via GET and POST' do
-    template = FactoryBot.create(:job_template, :with_input)
-    feature = FactoryBot.create(:remote_execution_feature, job_template: template)
-    params = { feature: feature.label, inputs: { template.template_inputs.first.name => 'foobar' } }
-
-    get :new, params: params, session: set_session_user
-    assert_response :success
-
-    post :new, params: params, session: set_session_user
-    assert_response :success
-  end
-
-  context 'restricted access' do
-    setup do
-      @admin = users(:admin)
-      @user = FactoryBot.create(:user, mail: 'test23@test.foreman.com', admin: false)
-      @invocation = FactoryBot.create(:job_invocation, :with_template, :with_task)
-      @invocation2 = FactoryBot.create(:job_invocation, :with_template, :with_task)
-
-      @invocation.task.update(user: @admin)
-      @invocation2.task.update(user: @user)
-
-      setup_user 'view', 'hosts', nil, @user
-      setup_user 'view', 'job_invocations', 'user = current_user', @user
-      setup_user 'create', 'job_invocations', 'user = current_user', @user
-      setup_user 'cancel', 'job_invocations', 'user = current_user', @user
-    end
-
-    context 'without user filter' do
-      test '#index' do
-        get :index, session: prepare_user(@admin)
-        assert_response :success
-        assert 2, assigns(:job_invocations).size
-      end
-
-      test '#show' do
-        get :show, params: { id: @invocation2.id }, session: prepare_user(@admin)
-        assert_response :success
-      end
-
-      test '#rerun' do
-        get :rerun, params: { id: @invocation2.id }, session: prepare_user(@admin)
-        assert_response :success
-      end
-
-      test '#cancel' do
-        ForemanTasks::Task.any_instance.expects(:cancel).returns(true)
-        post :cancel, params: { id: @invocation2.id }, session: prepare_user(@admin)
-        assert_response :redirect
-      end
-    end
-
-    context 'with user filter' do
-      test '#index' do
-        get :index, session: prepare_user(@user)
-        assert_response :success
-        assert_equal 1, assigns(:job_invocations).size
-        assert_equal @invocation2, assigns(:job_invocations)[0]
-      end
-
-      test '#show' do
-        get :show, params: { id: @invocation.id }, session: prepare_user(@user)
-        assert_response :not_found
-      end
-
-      test '#rerun' do
-        get :rerun, params: { id: @invocation.id }, session: prepare_user(@user)
-        assert_response :not_found
-      end
-
-      test 'cancel' do
-        post :cancel, params: { id: @invocation.id }, session: prepare_user(@user)
-        assert_response :not_found
-      end
-    end
-  end
-
-  def prepare_user(user)
-    User.current = user
-    set_session_user(user)
-  end
-end

data/test/functional/job_templates_controller_test.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_plugin_helper'
-
-class JobTemplatesControllerTest < ActionController::TestCase
-  context '#preview' do
-    let(:template) { FactoryBot.create(:job_template) }
-    let(:host) { FactoryBot.create(:host, :managed) }
-
-    test 'should render a preview version of a template' do
-      post :preview, params: { job_template: template.to_param, template: 'uptime' }, session: set_session_user
-      assert_response :success
-    end
-
-    test 'should render a preview version of a template for a specific host' do
-      post :preview, params: {
-        job_template: template.to_param,
-        template: '<%= @host.name %>',
-        preview_host_id: host.id,
-      }, session: set_session_user
-      assert_response :success
-      assert_equal host.name, @response.body
-    end
-
-    test 'should render a error message when template has errors' do
-      InputTemplateRenderer.any_instance.stubs(:render).returns(false)
-      post :preview, params: { job_template: template.to_param }, session: set_session_user
-      assert_response :not_acceptable
-    end
-  end
-end

data/test/functional/ui_job_wizard_controller_test.rb

@@ -1,16 +0,0 @@
-require 'test_plugin_helper'
-
-class UIJobWizardControllerTest < ActionController::TestCase
-  def setup
-    FactoryBot.create(:job_template, :job_category => 'cat1')
-    FactoryBot.create(:job_template, :job_category => 'cat2')
-    FactoryBot.create(:job_template, :job_category => 'cat2')
-  end
-
-  test 'should respond with categories' do
-    get :categories, :params => {}, :session => set_session_user
-    assert_response :success
-    res = JSON.parse @response.body
-    assert_equal ['cat1','cat2'], res['job_categories']
-  end
-end

data/test/graphql/mutations/job_invocations/create_test.rb

@@ -1,58 +0,0 @@
-require 'test_plugin_helper'
-
-module Mutations
-  module JobInvocations
-    class CreateMutationTest < ActiveSupport::TestCase
-      let(:host) { FactoryBot.create(:host) }
-      let(:job_template) { FactoryBot.create(:job_template, :with_input) }
-      let(:cron_line) { '5 * * * *' }
-      let(:purpose) { 'test' }
-      let(:variables) do
-        {
-          jobInvocation: {
-            hostIds: [host.id],
-            jobTemplateId: job_template.id,
-            targetingType: 'static_query',
-            inputs: { job_template.template_inputs.first.name => "bar" },
-            recurrence: {
-              cronLine: cron_line,
-              purpose:  purpose,
-            },
-          },
-        }
-      end
-
-      let(:query) do
-        <<-GRAPHQL
-          mutation CreateJobInvocation($jobInvocation: JobInvocationInput!) {
-              createJobInvocation(input: { jobInvocation: $jobInvocation }) {
-                jobInvocation {
-                  id
-                  description
-                  recurringLogic {
-                    cronLine
-                    purpose
-                  }
-                }
-              }
-            }
-        GRAPHQL
-      end
-
-      context 'with admin user' do
-        let(:user) { FactoryBot.create(:user, :admin) }
-        let(:context) { { current_user: user } }
-
-        test 'create a job invocation' do
-          assert_difference('JobInvocation.count', +1) do
-            result = ForemanGraphqlSchema.execute(query, variables: variables, context: context)
-            assert_empty result['errors']
-            assert_empty result['data']['createJobInvocation']['jobInvocation']['errors']
-            assert_equal cron_line, result['data']['createJobInvocation']['jobInvocation']['recurringLogic']['cronLine']
-            assert_equal purpose, result['data']['createJobInvocation']['jobInvocation']['recurringLogic']['purpose']
-          end
-        end
-      end
-    end
-  end
-end

data/test/graphql/queries/job_invocation_query_test.rb

@@ -1,31 +0,0 @@
-require 'test_helper'
-
-module Queries
-  class JobInvocationQueryTest < GraphQLQueryTestCase
-    let(:query) do
-      <<-GRAPHQL
-      query (
-        $id: String!
-      ) {
-        jobInvocation(id: $id) {
-          id
-          jobCategory
-        }
-      }
-      GRAPHQL
-    end
-
-    let(:job_invocation) { FactoryBot.create(:job_invocation) }
-
-    let(:global_id) { Foreman::GlobalId.for(job_invocation) }
-    let(:variables) { { id: global_id } }
-    let(:data) { result['data']['jobInvocation'] }
-
-    test 'fetching job invocation attributes' do
-      assert_empty result['errors']
-
-      assert_equal global_id, data['id']
-      assert_equal job_invocation.job_category, data['jobCategory']
-    end
-  end
-end

data/test/graphql/queries/job_invocations_query_test.rb

@@ -1,35 +0,0 @@
-require 'test_plugin_helper'
-
-module Queries
-  class JobInvocationsQueryTest < GraphQLQueryTestCase
-    let(:query) do
-      <<-GRAPHQL
-      query {
-        jobInvocations {
-          totalCount
-          nodes {
-            id
-            jobCategory
-          }
-        }
-      }
-      GRAPHQL
-    end
-
-    let(:data) { result['data']['jobInvocations'] }
-
-    setup do
-      FactoryBot.create_list(:job_invocation, 2)
-    end
-
-    test 'should fetch job invocations' do
-      assert_empty result['errors']
-
-      expected_count = JobInvocation.count
-
-      assert_not_equal 0, expected_count
-      assert_equal expected_count, data['totalCount']
-      assert_equal expected_count, data['nodes'].count
-    end
-  end
-end

data/test/helpers/remote_execution_helper_test.rb

@@ -1,46 +0,0 @@
-require 'test_plugin_helper'
-
-class RemoteExecutionHelperTest < ActionView::TestCase
-  describe '#normalize_line_sets' do
-    let :line_sets do
-      [{"output_type"=>"stdout", "output"=>"one", "timestamp"=>1},
-       {"output_type"=>"stdout", "output"=>"\r\ntwo\r\n", "timestamp"=>2},
-       {"output_type"=>"stdout", "output"=>"\r\nthr", "timestamp"=>3},
-       {"output_type"=>"stdout", "output"=>"ee\r\nfour\r\n", "timestamp"=>4},
-       {"output_type"=>"stdout", "output"=>"\r\n\r\n", "timestamp"=>5},
-       {"output_type"=>"stdout", "output"=>"five\r\n", "timestamp"=>6},
-       {"output_type"=>"stdout", "output"=>"Exit status: 0", "timestamp"=>7}]
-    end
-
-    it 'ensures the line sets end with new line' do
-      new_line_sets = normalize_line_sets(line_sets)
-      expected_output = ["one\r\n",
-                         "two\r\n",
-                         "\r\nthree\r\n",
-                         "four\r\n",
-                         "\r\n\r\n",
-                         "five\r\n",
-                         "Exit status: 0"]
-      assert_equal(expected_output, new_line_sets.map { |s| s['output'] })
-    end
-  end
-
-  describe 'test correct setting' do
-    it 'should found correct template from setting' do
-      template_name = 'Job Invocation Report Template'
-      setting_key = 'remote_execution_job_invocation_report_template'
-      template = FactoryBot.create(:report_template, name: template_name)
-      input = FactoryBot.create(:template_input, name: 'job_id', input_type: 'user')
-      template.template_inputs << input
-      Setting.expects(:[]).with(setting_key).returns(template_name)
-
-      found_template = job_report_template
-
-      assert_equal template.id, found_template.id
-    end
-
-    it 'should not crash if the template cannot be found' do
-      assert_nil job_report_template
-    end
-  end
-end

data/test/support/remote_execution_helper.rb

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

data/test/test_plugin_helper.rb

@@ -1,9 +0,0 @@
-# This calls the main test_helper in Foreman-core
-require 'test_helper'
-require 'dynflow/testing'
-
-# Add plugin to FactoryBot's paths
-FactoryBot.definition_file_paths << File.join(File.dirname(__FILE__), 'factories')
-# Add foreman tasks factories too
-FactoryBot.definition_file_paths << "#{ForemanTasks::Engine.root}/test/factories"
-FactoryBot.reload