foreman_remote_execution 14.0.2 → 14.1.0

data/test/unit/remote_execution_feature_test.rb

@@ -1,86 +0,0 @@
-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

@@ -1,298 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,206 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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