foreman_remote_execution 14.1.0 → 14.1.2

data/test/unit/remote_execution_feature_test.rb

@@ -0,0 +1,86 @@
+require 'test_plugin_helper'
+
+class RemoteExecutionFeatureTest < ActiveSupport::TestCase
+  should validate_presence_of(:name)
+  should validate_presence_of(:label)
+  should validate_uniqueness_of(:name)
+  should validate_uniqueness_of(:label)
+
+  let(:install_feature) do
+    RemoteExecutionFeature.register(:katello_install_package, N_('Katello: Install package'),
+      :description => 'Install package via Katello user interface',
+      :provided_inputs => ['package'])
+  end
+
+  let(:package_template) do
+    FactoryBot.create(:job_template).tap do |job_template|
+      job_template.job_category = 'Package Action'
+      job_template.name = 'Package Action - SSH Default'
+      job_template.template_inputs.create(:name => 'package', :input_type => 'user')
+    end
+  end
+
+  let(:host) { FactoryBot.create(:host) }
+
+  before do
+    User.current = users :admin
+    install_feature.update!(:job_template_id => package_template.id)
+  end
+
+  describe 'composer' do
+    it 'prepares composer for given feature based on the mapping' do
+      composer = JobInvocationComposer.for_feature(:katello_install_package, host, :package => 'zsh')
+      assert composer.valid?
+      assert_equal 1, composer.pattern_template_invocations.size
+      template_invocation = composer.pattern_template_invocations.first
+      assert_equal package_template, template_invocation.template
+      assert_equal 1, template_invocation.input_values.size
+
+      input_value = template_invocation.input_values.first
+      assert_equal 'zsh', input_value.value
+      assert_equal 'package', input_value.template_input.name
+
+      assert_equal "name ^ (#{host.name})", composer.targeting.search_query
+    end
+
+    it 'updates the feature when attributes change' do
+      updated_feature = RemoteExecutionFeature.register(install_feature.label, N_('Katello: Install package'),
+        :description => 'New description',
+        :provided_inputs => ['package', 'force'])
+      updated_feature.reload
+      assert_equal install_feature.id, updated_feature.id
+      assert_equal 'New description', updated_feature.description
+      assert_equal ['package', 'force'], updated_feature.provided_input_names
+    end
+  end
+
+  describe '.register' do
+    it "creates a feature if it's missing" do
+      feature = RemoteExecutionFeature.register('new_feature_that_does_not_exist', 'name')
+      assert_predicate feature, :persisted?
+      assert_equal 'new_feature_that_does_not_exist', feature.label
+      assert_equal 'name', feature.name
+      assert_not feature.host_action_button
+    end
+
+    it 'creates a feature with host action flag' do
+      feature = RemoteExecutionFeature.register('new_feature_that_does_not_exist_button', 'name', :host_action_button => true)
+      assert_predicate feature, :persisted?
+      assert feature.host_action_button
+    end
+
+    it 'created feature with host action flag can be found using named scope' do
+      feature = RemoteExecutionFeature.register('new_feature_that_does_not_exist_button', 'name', :host_action_button => true)
+      assert_includes RemoteExecutionFeature.with_host_action_button, feature
+    end
+
+
+    it 'updates a feature if it exists' do
+      existing = FactoryBot.create(:remote_execution_feature, :name => 'existing_feature_withou_action_button')
+      feature = RemoteExecutionFeature.register(existing.label, existing.name, :host_action_button => true)
+      assert_predicate feature, :persisted?
+      existing.reload
+      assert existing.host_action_button
+    end
+  end
+end

data/test/unit/remote_execution_provider_test.rb

@@ -0,0 +1,298 @@
+require 'test_plugin_helper'
+
+class RemoteExecutionProviderTest < ActiveSupport::TestCase
+  describe '.providers' do
+    let(:providers) { RemoteExecutionProvider.providers }
+    it { assert_kind_of HashWithIndifferentAccess, providers }
+    it 'makes providers accessible using symbol' do
+      assert_equal SSHExecutionProvider, providers[:SSH]
+      assert_equal ScriptExecutionProvider, providers[:script]
+    end
+    it 'makes providers accessible using string' do
+      assert_equal SSHExecutionProvider, providers['SSH']
+      assert_equal ScriptExecutionProvider, providers['script']
+    end
+  end
+
+  describe '.register_provider' do
+    before { RemoteExecutionProvider.providers.delete(:new) }
+    let(:new_provider) { RemoteExecutionProvider.providers[:new] }
+    it { assert_nil new_provider }
+
+    context 'registers a provider under key :new' do
+      before { RemoteExecutionProvider.register(:new, String) }
+      it { assert_equal String, new_provider }
+    end
+  end
+
+  describe '.provider_for' do
+    it 'accepts symbols' do
+      assert_equal SSHExecutionProvider, RemoteExecutionProvider.provider_for(:SSH)
+    end
+
+    it 'accepts strings' do
+      assert_equal SSHExecutionProvider, RemoteExecutionProvider.provider_for('SSH')
+    end
+
+    it 'returns a default one if unknown value is provided' do
+      assert_equal ScriptExecutionProvider, RemoteExecutionProvider.provider_for('WinRM')
+    end
+  end
+
+  describe '.provider_names' do
+    let(:provider_names) { RemoteExecutionProvider.provider_names }
+
+    it 'returns only strings' do
+      provider_names.each do |name|
+        assert_kind_of String, name
+      end
+    end
+
+    context 'provider is registetered under :custom symbol' do
+      before { RemoteExecutionProvider.register(:Custom, String) }
+
+      it { assert_includes provider_names, 'SSH' }
+      it { assert_includes provider_names, 'Custom' }
+    end
+  end
+
+  describe '.proxy_feature' do
+    # rubocop:disable Naming/ConstantName
+    it 'handles provider subclasses properly' do
+      old = ::RemoteExecutionProvider
+
+      class P2 < old
+      end
+      ::RemoteExecutionProvider = P2
+
+      class CustomProvider < ::RemoteExecutionProvider
+      end
+
+      ::RemoteExecutionProvider.register('custom', CustomProvider)
+
+      feature = CustomProvider.proxy_feature
+      assert_equal 'custom', feature
+    ensure
+      ::RemoteExecutionProvider = old
+    end
+    # rubocop:enable Naming/ConstantName
+  end
+
+  describe '.provider_proxy_features' do
+    it 'returns correct values' do
+      RemoteExecutionProvider.stubs(:providers).returns(
+        :SSH => SSHExecutionProvider,
+        :script => ScriptExecutionProvider
+      )
+
+      features = RemoteExecutionProvider.provider_proxy_features
+      assert_includes features, 'SSH'
+      assert_includes features, 'Script'
+      RemoteExecutionProvider.unstub(:providers)
+    end
+
+    it 'can deal with non-arrays' do
+      provider = OpenStruct.new(proxy_feature: 'Testing')
+      RemoteExecutionProvider.stubs(:providers).returns(:testing => provider)
+      features = RemoteExecutionProvider.provider_proxy_features
+      assert_includes features, 'Testing'
+      RemoteExecutionProvider.unstub(:providers)
+    end
+  end
+
+  describe '.host_setting' do
+    let(:host) { FactoryBot.create(:host) }
+
+    it 'honors falsey values set as a host parameter' do
+      key = 'remote_execution_connect_by_ip'
+      Setting[key] = true
+      host.parameters << HostParameter.new(name: key, value: false)
+
+      refute RemoteExecutionProvider.host_setting(host, key)
+    end
+  end
+
+  describe SSHExecutionProvider do
+    before { User.current = FactoryBot.build(:user, :admin) }
+    after { User.current = nil }
+
+    let(:job_invocation) { FactoryBot.create(:job_invocation, :with_template) }
+    let(:template_invocation) { job_invocation.pattern_template_invocations.first }
+    let(:host) { FactoryBot.create(:host) }
+    let(:proxy_options) { SSHExecutionProvider.proxy_command_options(template_invocation, host) }
+    let(:secrets) { SSHExecutionProvider.secrets(host) }
+
+    describe 'effective user' do
+      it 'takes the effective user from value from the template invocation' do
+        template_invocation.effective_user = 'my user'
+        assert_equal 'my user', proxy_options[:effective_user]
+      end
+    end
+
+    describe 'ssh user' do
+      it 'uses the remote_execution_ssh_user on the host param' do
+        host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_ssh_user', :value => 'my user')
+        assert_equal 'my user', proxy_options[:ssh_user]
+      end
+    end
+
+    describe 'effective user password' do
+      it 'uses the remote_execution_effective_user_password on the host param' do
+        host.params['remote_execution_effective_user_password'] = 'mypassword'
+        host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_effective_user_password', :value => 'mypassword')
+        assert_nil proxy_options[:effective_user_password]
+        assert_equal 'mypassword', secrets[:effective_user_password]
+      end
+    end
+
+    describe 'sudo' do
+      it 'uses the remote_execution_effective_user_method on the host param' do
+        host.params['remote_execution_effective_user_method'] = 'sudo'
+        method_param = FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_effective_user_method', :value => 'sudo')
+        host.host_parameters << method_param
+        assert_equal 'sudo', proxy_options[:effective_user_method]
+        method_param.update!(:value => 'su')
+        host.clear_host_parameters_cache!
+        proxy_options = SSHExecutionProvider.proxy_command_options(template_invocation, host)
+        assert_equal 'su', proxy_options[:effective_user_method]
+        method_param.update!(:value => 'dzdo')
+        host.clear_host_parameters_cache!
+        proxy_options = SSHExecutionProvider.proxy_command_options(template_invocation, host)
+        assert_equal 'dzdo', proxy_options[:effective_user_method]
+      end
+    end
+
+    describe 'ssh port from settings' do
+      before do
+        Setting[:remote_execution_ssh_port] = '66'
+      end
+
+      it 'has ssh port changed in settings and check return type' do
+        assert_kind_of Integer, proxy_options[:ssh_port]
+        assert_equal 66, proxy_options[:ssh_port]
+      end
+    end
+
+    describe 'ssh port from params' do
+      it 'takes ssh port number from params and check return type' do
+        host.params['remote_execution_ssh_port'] = '30'
+        host.host_parameters << FactoryBot.build(:host_parameter, :name => 'remote_execution_ssh_port', :value => '30')
+        host.clear_host_parameters_cache!
+        assert_kind_of Integer, proxy_options[:ssh_port]
+        assert_equal 30, proxy_options[:ssh_port]
+      end
+    end
+
+    describe 'cleanup working directories setting' do
+      before do
+        Setting[:remote_execution_cleanup_working_dirs] = false
+      end
+
+      it 'updates the value via settings' do
+        refute proxy_options[:cleanup_working_dirs]
+      end
+    end
+
+    describe 'cleanup working directories from parameters' do
+      it 'takes the value from host parameters' do
+        host.params['remote_execution_cleanup_working_dirs'] = 'false'
+        host.host_parameters << FactoryBot.build(:host_parameter, :name => 'remote_execution_cleanup_working_dirs', :value => 'false')
+        host.clear_host_parameters_cache!
+        refute proxy_options[:cleanup_working_dirs]
+      end
+    end
+
+    describe '#find_ip_or_hostname' do
+      let(:host) do
+        FactoryBot.create(:host) do |host|
+          host.interfaces = [FactoryBot.build(:nic_managed, flags.merge(:ip => nil, :name => 'somehost.somedomain.org', :primary => true)),
+                             FactoryBot.build(:nic_managed, flags.merge(:ip => '127.0.0.1'))]
+        end.reload
+        # Reassigning the interfaces triggers the on-deletion ssh key removal for the interface which is being replaced
+        # This has an undesired side effect of caching the original interface as execution one which made the tests
+        # give wrong results. Reloading the host wipes the cache
+      end
+
+      let(:flags) do
+        { :primary => false, :provision => false, :execution => false }
+      end
+
+      it 'gets fqdn from flagged interfaces if not preferring ips' do
+        # falling to primary interface
+        assert_equal 'somehost.somedomain.org', SSHExecutionProvider.find_ip_or_hostname(host)
+
+        # execution wins if present
+        execution_interface = FactoryBot.build(:nic_managed,
+          flags.merge(:execution => true, :name => 'special.somedomain.org'))
+        host.interfaces << execution_interface
+        host.primary_interface.update(:execution => false)
+        host.interfaces.each(&:save)
+        host.reload
+        assert_equal execution_interface.fqdn, SSHExecutionProvider.find_ip_or_hostname(host)
+      end
+
+      it 'gets ip from flagged interfaces' do
+        host.host_params['remote_execution_connect_by_ip'] = true
+        # no ip address set on relevant interface - fallback to fqdn
+        assert_equal 'somehost.somedomain.org', SSHExecutionProvider.find_ip_or_hostname(host)
+
+        # provision interface with ip while primary without
+        provision_interface = FactoryBot.build(:nic_managed,
+          flags.merge(:provision => true, :ip => '10.0.0.1'))
+        host.interfaces << provision_interface
+        host.primary_interface.update(:provision => false)
+        host.interfaces.each(&:save)
+        host.reload
+        assert_equal provision_interface.ip, SSHExecutionProvider.find_ip_or_hostname(host)
+
+        # both primary and provision interface have IPs: the primary wins
+        host.primary_interface.update(:ip => '10.0.0.2', :execution => false)
+        host.reload
+        assert_equal host.primary_interface.ip, SSHExecutionProvider.find_ip_or_hostname(host)
+
+        # there is an execution interface with IP: it wins
+        execution_interface = FactoryBot.build(:nic_managed,
+          flags.merge(:execution => true, :ip => '10.0.0.3'))
+        host.interfaces << execution_interface
+        host.primary_interface.update(:execution => false)
+        host.interfaces.each(&:save)
+        host.reload
+        assert_equal execution_interface.ip, SSHExecutionProvider.find_ip_or_hostname(host)
+
+        # there is an execution interface with both IPv6 and IPv4: IPv4 is being preferred over IPv6 by default
+        execution_interface = FactoryBot.build(:nic_managed,
+          flags.merge(:execution => true, :ip => '10.0.0.4', :ip6 => 'fd00::4'))
+        host.interfaces = [execution_interface]
+        host.interfaces.each(&:save)
+        host.reload
+        assert_equal execution_interface.ip, SSHExecutionProvider.find_ip_or_hostname(host)
+      end
+
+      it 'gets ipv6 from flagged interfaces with IPv6 preference' do
+        host.host_params['remote_execution_connect_by_ip_prefer_ipv6'] = true
+        host.host_params['remote_execution_connect_by_ip'] = true
+
+        # there is an execution interface with both IPv6 and IPv4: IPv6 is being preferred over IPv4 by host parameter configuration
+        execution_interface = FactoryBot.build(:nic_managed,
+          flags.merge(:execution => true, :ip => '10.0.0.4', :ip6 => 'fd00::4'))
+        host.interfaces = [execution_interface]
+        host.interfaces.each(&:save)
+        host.reload
+        assert_equal execution_interface.ip6, SSHExecutionProvider.find_ip_or_hostname(host)
+      end
+
+      it 'gets ipv6 from flagged interfaces with IPv4 preference but without IPv4 address' do
+        host.host_params['remote_execution_connect_by_ip_prefer_ipv6'] = false
+        host.host_params['remote_execution_connect_by_ip'] = true
+
+        # there is an execution interface with both IPv6 and IPv4: IPv6 is being preferred over IPv4 by host parameter configuration
+        execution_interface = FactoryBot.build(:nic_managed,
+          flags.merge(:execution => true, :ip => nil, :ip6 => 'fd00::4'))
+        host.interfaces = [execution_interface]
+        host.interfaces.each(&:save)
+        host.reload
+        assert_equal execution_interface.ip6, SSHExecutionProvider.find_ip_or_hostname(host)
+      end
+    end
+  end
+end

data/test/unit/renderer_scope_input_test.rb

@@ -0,0 +1,49 @@
+require 'test_plugin_helper'
+
+class RendererScopeInputTest < ActiveSupport::TestCase
+  let(:source) { Foreman::Renderer::Source::String.new(content: '') }
+
+  describe 'caching helper in real mode' do
+    let(:input) do
+      input = ForemanRemoteExecution::Renderer::Scope::Input.new(source: source)
+      input.stubs(:invocation => OpenStruct.new(:job_invocation_id => 1))
+      input
+    end
+
+    it 'caches the value under given key' do
+      i = 1
+      result = input.cached('some_key') { i }
+      assert_equal 1, result
+
+      i += 1
+      result = input.cached('some_key') { i }
+      assert_equal 1, result
+
+      i += 1
+      result = input.cached('different_key') { i }
+      assert_equal 3, result
+    end
+  end
+
+  describe 'caching helper in preview mode' do
+    let(:input) do
+      input = ForemanRemoteExecution::Renderer::Scope::Input.new(source: source)
+      input.stubs(:invocation => OpenStruct.new(:job_invocation_id => 1), :preview? => true)
+      input
+    end
+
+    it 'does not cache the value' do
+      i = 1
+      result = input.cached('some_key') { i }
+      assert_equal 1, result
+
+      i += 1
+      result = input.cached('some_key') { i }
+      assert_equal 2, result
+
+      i += 1
+      result = input.cached('different_key') { i }
+      assert_equal 3, result
+    end
+  end
+end

data/test/unit/targeting_test.rb

@@ -0,0 +1,206 @@
+require 'test_plugin_helper'
+
+class TargetingTest < ActiveSupport::TestCase
+  let(:targeting) { FactoryBot.build(:targeting) }
+  let(:bookmark) { bookmarks(:one) }
+  let(:host) { FactoryBot.create(:host) }
+
+  before do
+    bookmark.query = 'name = bar'
+  end
+
+  describe '#resolved?' do
+    context 'resolved_at is nil' do
+      before { targeting.resolved_at = nil }
+      it { assert_not targeting.resolved? }
+    end
+
+    context 'resolved_at is set' do
+      before { targeting.resolved_at = Time.now.getlocal }
+      it { assert targeting.resolved? }
+    end
+
+  end
+
+  context 'able to be created with search term' do
+    before { targeting.search_query = 'name = foo' }
+    it { assert targeting.save }
+  end
+
+  context 'able to be created with a bookmark' do
+    before do
+      targeting.search_query = nil
+      targeting.bookmark = bookmark
+    end
+    it { assert_valid targeting }
+  end
+
+  context 'cannot create without search term or bookmark' do
+    before do
+      targeting.targeting_type = Targeting::DYNAMIC_TYPE
+      targeting.search_query = ''
+      targeting.bookmark = nil
+    end
+    it { refute_valid targeting }
+  end
+
+  context 'can resolve hosts via query' do
+    before do
+      targeting.user = users(:admin)
+      targeting.search_query = "name = #{host.name}"
+      targeting.resolve_hosts!
+    end
+
+    it { assert_includes targeting.hosts, host }
+  end
+
+  context 'can delete a user' do
+    before do
+      targeting.user = users(:one)
+      targeting.save!
+      users(:one).destroy
+    end
+
+    it { assert_nil targeting.reload.user }
+    it do
+      assert_raises(Foreman::Exception) { targeting.resolve_hosts! }
+    end
+  end
+
+  context 'can delete a host' do
+    before do
+      targeting.hosts << host
+      targeting.save!
+      host.destroy
+    end
+
+    it { assert_empty targeting.reload.hosts }
+  end
+
+  describe '#resolve_hosts!' do
+    let(:second_host) { FactoryBot.create(:host) }
+    let(:infra_host) { FactoryBot.create(:host, :with_infrastructure_facet) }
+    let(:targeting) { FactoryBot.build(:targeting) }
+
+    before do
+      host
+      second_host
+      infra_host
+    end
+
+    context 'with infrastructure host permission' do
+      before do
+        setup_user('view', 'hosts')
+        setup_user('execute_jobs_on', 'infrastructure_hosts')
+      end
+
+      it 'resolves all hosts' do
+        hosts = [host, second_host, infra_host]
+        targeting.search_query = "name ^ (#{hosts.map(&:name).join(',')})"
+        targeting.user = User.current
+        targeting.resolve_hosts!
+
+        assert_includes targeting.hosts, host
+        assert_includes targeting.hosts, second_host
+        assert_includes targeting.hosts, infra_host
+      end
+    end
+
+    context 'without infrastructure host permission' do
+      before { setup_user('view', 'hosts') }
+
+      it 'ignores infrastructure hosts' do
+        hosts = [host, second_host, infra_host]
+        targeting.search_query = "name ^ (#{hosts.map(&:name).join(',')})"
+        targeting.user = User.current
+        targeting.resolve_hosts!
+
+        assert_includes targeting.hosts, host
+        assert_includes targeting.hosts, second_host
+        refute_includes targeting.hosts, infra_host
+      end
+    end
+  end
+
+  describe '#build_query_from_hosts(ids)' do
+    let(:second_host) { FactoryBot.create(:host) }
+    let(:infra_host) { FactoryBot.create(:host, :with_infrastructure_facet) }
+
+    before do
+      host
+      second_host
+      infra_host
+    end
+
+    context 'for two hosts' do
+      let(:query) { Targeting.build_query_from_hosts([ host.id, second_host.id, infra_host.id ]) }
+
+      it 'builds query using host names joining inside ^' do
+        assert_includes query, host.name
+        assert_includes query, second_host.name
+        assert_includes query, infra_host.name
+        assert_includes query, 'name ^'
+
+        assert_includes Host.search_for(query), host
+        assert_includes Host.search_for(query), second_host
+        assert_includes Host.search_for(query), infra_host
+      end
+    end
+
+    context 'for one host' do
+      let(:query) { Targeting.build_query_from_hosts([ host.id ]) }
+
+      it 'builds query using host name' do
+        assert_equal "name ^ (#{host.name})", query
+        assert_includes Host.search_for(query), host
+        refute_includes Host.search_for(query), second_host
+        refute_includes Host.search_for(query), infra_host
+      end
+    end
+
+    context 'for no id' do
+      let(:query) { Targeting.build_query_from_hosts([]) }
+
+      it 'builds query to find all hosts' do
+        assert_includes Host.search_for(query), host
+        assert_includes Host.search_for(query), second_host
+        assert_includes Host.search_for(query), infra_host
+      end
+    end
+
+    context 'without infrastructure host permission' do
+      before { User.current = nil }
+
+      it 'ignores the infrastructure host' do
+        query = Targeting.build_query_from_hosts([host.id, second_host.id, infra_host.id])
+        assert_includes query, host.name
+        assert_includes query, second_host.name
+        refute_includes query, infra_host.name
+        assert_includes query, 'name ^'
+
+        assert_includes Host.search_for(query), host
+        assert_includes Host.search_for(query), second_host
+        refute_includes Host.search_for(query), infra_host
+      end
+    end
+  end
+
+  context 'randomized ordering' do
+    let(:targeting) { FactoryBot.build(:targeting, :with_randomized_ordering) }
+    let(:hosts) { (0..4).map { FactoryBot.create(:host) } }
+
+    it 'loads the hosts in random order' do
+      rng = Random.new(4) # Chosen by a fair dice roll
+      Random.stubs(:new).returns(rng)
+      hosts
+      targeting.search_query = 'name ~ host*'
+      targeting.user = users(:admin)
+      targeting.resolve_hosts!
+      randomized_host_ids = targeting.hosts.map(&:id)
+      host_ids = hosts.map(&:id)
+
+      assert_not_equal host_ids, randomized_host_ids
+      assert_equal host_ids, randomized_host_ids.sort
+    end
+  end
+end

data/test/unit/template_invocation_input_value_test.rb

@@ -0,0 +1,38 @@
+require 'test_plugin_helper'
+
+class TemplateInvocationInputTest < ActiveSupport::TestCase
+  let(:template) { FactoryBot.build(:job_template, :template => 'service restart <%= input("service_name") -%>') }
+  let(:renderer) { InputTemplateRenderer.new(template) }
+  let(:job_invocation) { FactoryBot.create(:job_invocation) }
+  let(:template_invocation) { FactoryBot.build(:template_invocation, :template => template) }
+  let(:result) { renderer.render }
+
+  context 'with selectable options' do
+    before do
+      result # let is lazy
+      template.template_inputs << FactoryBot.build(:template_input, :name => 'service_name', :input_type => 'user',
+                                                                    :required => true, :options => "foreman\nhttpd")
+    end
+
+    it 'fails with an invalid option' do
+      refute_valid FactoryBot.build(:template_invocation_input_value, :template_invocation => template_invocation,
+                                                                      :template_input => template.template_inputs.first,
+                                                                      :value => 'sendmail')
+    end
+
+    it 'succeeds with valid option' do
+      assert_valid FactoryBot.build(:template_invocation_input_value, :template_invocation => template_invocation,
+                                                                      :template_input => template.template_inputs.first,
+                                                                      :value => 'foreman')
+    end
+  end
+
+  it 'supports large inputs' do
+    template.template_inputs << FactoryBot.build(:template_input, :name => 'service_name',
+                                                                  :input_type => 'user', :required => true)
+    assert_valid FactoryBot.create(:template_invocation_input_value,
+      :template_invocation => template_invocation,
+      :template_input => template.template_inputs.first,
+      :value => 'foreman' * 1_000_000)
+  end
+end