foreman_salt 14.0.0 → 15.1.0

data/db/seeds.d/76-job_templates.rb

@@ -15,13 +15,15 @@ if ForemanSalt.with_remote_execution?
         ForemanSalt.register_rex_feature
       end
       JobTemplate.without_auditing do
-        Dir[File.join("#{ForemanSalt::Engine.root}/app/views/foreman_salt/"\
-                    'job_templates/**/*.erb')].each do |template|
+        templates = Dir[File.join("#{ForemanSalt::Engine.root}/app/views/foreman_salt/"\
+                    'job_templates/**/*.erb')]
+        first = templates.select { |d| File.basename(d).start_with?('salt_run_function') }
+        (first + (templates - first)).each do |template|
           sync = !Rails.env.test? && Setting[:remote_execution_sync_templates]
           template = JobTemplate.import_raw!(File.read(template),
-                                             :default => true,
-                                             :lock => true,
-                                             :update => sync)
+            default: true,
+            lock: true,
+            update: sync)
           template.organizations = organizations if template.present?
           template.locations = locations if template.present?
         end

data/lib/foreman_salt/engine.rb

@@ -12,18 +12,14 @@ module ForemanSalt
     config.autoload_paths += Dir["#{config.root}/app/services"]
     config.autoload_paths += Dir["#{config.root}/app/lib"]
 
-    initializer 'foreman_salt.require_dynflow', :before => 'foreman_tasks.initialize_dynflow' do
-      ForemanTasks.dynflow.require!
-    end
+    config.paths['config/routes.rb'].unshift('config/api_routes.rb')
 
-    initializer 'foreman_salt.load_default_settings', :before => :load_config_initializers do
-      if (Setting.table_exists? rescue(false))
-        require_dependency File.expand_path('../../../app/models/setting/salt.rb', __FILE__)
-      end
+    initializer 'foreman_salt.require_dynflow', before: 'foreman_tasks.initialize_dynflow' do
+      ForemanTasks.dynflow.require!
     end
 
     initializer 'foreman_salt.register_gettext',
-                :after => :load_config_initializers do
+      after: :load_config_initializers do
       locale_dir = File.join(File.expand_path('../..', __dir__), 'locale')
       locale_domain = 'foreman_salt'
 
@@ -37,16 +33,16 @@ module ForemanSalt
     end
 
     initializer 'foreman_salt.assets.precompile' do |app|
-      app.config.assets.precompile += %w(foreman_salt/states.js)
+      app.config.assets.precompile += %w[foreman_salt/states.js]
       app.config.assets.precompile += %w[foreman_salt/Salt.png]
     end
 
-    initializer 'foreman_salt.configure_assets', :group => :assets do
+    initializer 'foreman_salt.configure_assets', group: :assets do
       SETTINGS[:foreman_salt] = {
-        :assets => {
-          :precompile => ['foreman_salt/Salt.png',
-                          'foreman_salt/states.js']
-        }
+        assets: {
+          precompile: ['foreman_salt/Salt.png',
+                       'foreman_salt/states.js'],
+        },
       }
     end
 
@@ -54,7 +50,7 @@ module ForemanSalt
       Apipie.configuration.checksum_path += ['/salt/api/']
     end
 
-    initializer 'foreman_salt.register_plugin', :before => :finisher_hook do
+    initializer 'foreman_salt.register_plugin', before: :finisher_hook do
       require 'foreman_salt/plugin'
     end
 
@@ -68,15 +64,17 @@ module ForemanSalt
 
   # check whether foreman_remote_execution to integrate is available in the system
   def self.with_remote_execution?
-    RemoteExecutionFeature rescue false
+    RemoteExecutionFeature
+  rescue StandardError
+    false
   end
 
   def self.register_rex_feature
     options = {
-      :description => N_("Run Salt state.highstate"),
-      :host_action_button => true
+      description: N_('Run Salt state.highstate'),
+      host_action_button: true,
     }
 
-    RemoteExecutionFeature.register(:foreman_salt_run_state_highstate, N_("Run Salt"), options)
+    RemoteExecutionFeature.register(:foreman_salt_run_state_highstate, N_('Run Salt'), options)
   end
 end

data/lib/foreman_salt/extensions.rb

@@ -1,15 +1,15 @@
 begin
   # Helper Extensions
-  ::HostsHelper.send :include, ForemanSalt::HostsHelperExtensions
-  ::SmartProxiesHelper.send :include, ForemanSalt::SmartProxiesHelperExtensions
+  ::HostsHelper.include ForemanSalt::HostsHelperExtensions
+  ::SmartProxiesHelper.include ForemanSalt::SmartProxiesHelperExtensions
 
   # Model Extensions
-  ::Host::Managed.send :include, ForemanSalt::Concerns::HostManagedExtensions
-  ::Hostgroup.send :include, ForemanSalt::Concerns::HostgroupExtensions
+  ::Host::Managed.include ForemanSalt::Concerns::HostManagedExtensions
+  ::Hostgroup.include ForemanSalt::Concerns::HostgroupExtensions
 
   # Controller Extensions
-  ::HostsController.send :include, ForemanSalt::Concerns::HostsControllerExtensions
-  ::HostgroupsController.send :include, ForemanSalt::Concerns::HostgroupsControllerExtensions
-rescue => e
-  puts "ForemanSalt: skipping engine hook (#{e})"
+  ::HostsController.include ForemanSalt::Concerns::HostsControllerExtensions
+  ::HostgroupsController.include ForemanSalt::Concerns::HostgroupsControllerExtensions
+rescue StandardError => e
+  Rails.logger.error "ForemanSalt: skipping engine hook (#{e})"
 end

data/lib/foreman_salt/plugin.rb

@@ -1,183 +1,199 @@
 # frozen_string_literal: true
 
-# rubocop:disable BlockLength
 Foreman::Plugin.register :foreman_salt do
   requires_foreman '>= 1.24'
 
+  settings do
+    category(:cfgmgmt, N_('Config Management')) do
+      setting('salt_namespace_pillars',
+        type: :boolean,
+        description: N_("Namespace Foreman pillars under 'foreman' key"),
+        default: false,
+        full_name: N_('Salt namespace pillars'))
+    end
+  end
+
   apipie_documented_controllers ["#{ForemanSalt::Engine.root}/app/controllers/foreman_salt/api/v2/*.rb"]
 
   # Menus
-  divider :top_menu, :parent => :configure_menu, :caption => 'Salt'
+  divider :top_menu, parent: :configure_menu, caption: 'Salt'
   menu :top_menu, :salt_environments,
-       :url_hash => { :controller => :'foreman_salt/salt_environments', :action => :index },
-       :caption  => 'Environments',
-       :parent   => :configure_menu
+    url_hash: { controller: :'foreman_salt/salt_environments', action: :index },
+    caption: 'Environments',
+    parent: :configure_menu
 
   menu :top_menu, :salt_modules,
-       :url_hash => { :controller => :'foreman_salt/salt_modules', :action => :index },
-       :caption  => 'States',
-       :parent   => :configure_menu
+    url_hash: { controller: :'foreman_salt/salt_modules', action: :index },
+    caption: 'States',
+    parent: :configure_menu
 
   menu :top_menu, :salt_variables,
-       :url_hash => { :controller => :'foreman_salt/salt_variables', :action => :index },
-       :caption => N_('Variables'),
-       :parent => :configure_menu
+    url_hash: { controller: :'foreman_salt/salt_variables', action: :index },
+    caption: N_('Variables'),
+    parent: :configure_menu
+
+  # Existing permissions
+  p = Foreman::AccessControl.permission(:edit_hostgroups)
+  p.actions << 'foreman_salt/api/v2/salt_hostgroups/update'
+  p.actions << 'hostgroups/salt_environment_selected'
 
+  p = Foreman::AccessControl.permission(:view_hostgroups)
+  p.actions << 'foreman_salt/api/v2/salt_hostgroups/show'
 
-  # Permissions
+  # New permissions
   security_block :foreman_salt do
+    permission :auth_smart_proxies_salt_autosign,
+      { 'foreman_salt/api/v2/salt_autosign': [:auth] },
+      resource_type: 'SmartProxy'
+
     permission :destroy_smart_proxies_salt_autosign,
-               { :'foreman_salt/salt_autosign' => [:destroy],
-                 :'foreman_salt/api/v2/salt_autosign' => [:destroy] },
-               :resource_type => 'SmartProxy'
+      { 'foreman_salt/salt_autosign': [:destroy],
+        'foreman_salt/api/v2/salt_autosign': [:destroy] },
+      resource_type: 'SmartProxy'
 
     permission :create_smart_proxies_salt_autosign,
-               { :'foreman_salt/salt_autosign' => [:new, :create],
-                 :'foreman_salt/api/v2/salt_autosign' => [:create] },
-               :resource_type => 'SmartProxy'
+      { 'foreman_salt/salt_autosign': %i[new create],
+        'foreman_salt/api/v2/salt_autosign': [:create] },
+      resource_type: 'SmartProxy'
 
     permission :view_smart_proxies_salt_autosign,
-               { :'foreman_salt/salt_autosign' => [:index],
-                 :'foreman_salt/api/v2/salt_autosign' => [:index] },
-               :resource_type => 'SmartProxy'
+      { 'foreman_salt/salt_autosign': [:index],
+        'foreman_salt/api/v2/salt_autosign': [:index] },
+      resource_type: 'SmartProxy'
 
     permission :create_salt_environments,
-               { :'foreman_salt/salt_environments' => [:new, :create],
-                 :'foreman_salt/api/v2/salt_environments' => [:create] },
-               :resource_type => 'ForemanSalt::SaltEnvironment'
+      { 'foreman_salt/salt_environments': %i[new create],
+        'foreman_salt/api/v2/salt_environments': [:create] },
+      resource_type: 'ForemanSalt::SaltEnvironment'
 
     permission :view_salt_environments,
-               { :'foreman_salt/salt_environments' => [:index, :show, :auto_complete_search],
-                 :'foreman_salt/api/v2/salt_environments' => [:index, :show] },
-               :resource_type => 'ForemanSalt::SaltEnvironment'
+      { 'foreman_salt/salt_environments': %i[index show auto_complete_search],
+        'foreman_salt/api/v2/salt_environments': %i[index show] },
+      resource_type: 'ForemanSalt::SaltEnvironment'
 
     permission :edit_salt_environments,
-               { :'foreman_salt/salt_environments' => [:update, :edit] },
-               :resource_type => 'ForemanSalt::SaltEnvironment'
+      { 'foreman_salt/salt_environments': %i[update edit] },
+      resource_type: 'ForemanSalt::SaltEnvironment'
 
     permission :destroy_salt_environments,
-               { :'foreman_salt/salt_environments' => [:destroy],
-                 :'foreman_salt/api/v2/salt_environments' => [:destroy] },
-               :resource_type => 'ForemanSalt::SaltEnvironment'
+      { 'foreman_salt/salt_environments': [:destroy],
+        'foreman_salt/api/v2/salt_environments': [:destroy] },
+      resource_type: 'ForemanSalt::SaltEnvironment'
 
     permission :view_salt_variables,
-               {
-                 :'foreman_salt/salt_variables' => [:index, :auto_complete_search],
-                 :'foreman_salt/api/v2/salt_variables' => [:index, :show]
-               },
-               :resource_type => 'ForemanSalt::SaltVariable'
+      { 'foreman_salt/salt_variables': %i[index auto_complete_search],
+        'foreman_salt/api/v2/salt_variables': %i[index show],
+        'lookup_values': [:index] },
+      resource_type: 'ForemanSalt::SaltVariable'
 
     permission :edit_salt_variables,
-               { :'foreman_salt/salt_variables' => [:edit, :update],
-                 :'foreman_salt/api/v2/salt_variables' => [:update],
-                 :'foreman_salt/api/v2/salt_override_values' => [:create, :destroy] },
-               :resource_type => 'ForemanSalt::SaltVariable'
+      { 'foreman_salt/salt_variables': %i[edit update],
+        'foreman_salt/api/v2/salt_variables': [:update],
+        'lookup_values': [:update] },
+      resource_type: 'ForemanSalt::SaltVariable'
 
     permission :destroy_salt_variables,
-               {
-                 :'foreman_salt/salt_variables' => [:destroy],
-                 :'foreman_salt/api/v2/salt_variables' => [:destroy]
-               },
-               :resource_type => 'ForemanSalt::SaltVariable'
+      { 'foreman_salt/salt_variables': [:destroy],
+        'foreman_salt/api/v2/salt_variables': [:destroy],
+        'foreman_salt/api/v2/salt_override_values': [:destroy],
+        'lookup_values': [:destroy] },
+      resource_type: 'ForemanSalt::SaltVariable'
 
     permission :create_salt_variables,
-               {
-                 :'foreman_salt/salt_variables' => [:new, :create],
-                 :'foreman_salt/api/v2/salt_variables' => [:create]
-               },
-               :resource_type => 'ForemanSalt::SaltVariable'
+      { 'foreman_salt/salt_variables': %i[new create],
+        'foreman_salt/api/v2/salt_variables': [:create],
+        'foreman_salt/api/v2/salt_override_values': [:create],
+        'lookup_values': [:create] },
+      resource_type: 'ForemanSalt::SaltVariable'
 
     permission :create_reports,
-               { :'foreman_salt/api/v2/jobs' => [:upload] },
-               :resource_type => 'Report'
+      { 'foreman_salt/api/v2/jobs': [:upload] },
+      resource_type: 'Report'
 
     permission :saltrun_hosts,
-               { :'foreman_salt/minions' => [:run] },
-               :resource_type => 'Host'
+      { 'foreman_salt/minions': [:run] },
+      resource_type: 'Host'
 
     permission :edit_hosts,
-               { :'foreman_salt/api/v2/salt_minions' => [:update],
-                 :'foreman_salt/minions' => [:salt_environment_selected],
-                 :hosts => [:select_multiple_salt_master, :update_multiple_salt_master,
-                            :select_multiple_salt_environment, :update_multiple_salt_environment] },
-               :resource_type => 'Host'
+      { 'foreman_salt/api/v2/salt_minions': [:update],
+        'foreman_salt/minions': [:salt_environment_selected],
+        hosts: %i[select_multiple_salt_master update_multiple_salt_master
+                  select_multiple_salt_environment update_multiple_salt_environment] },
+      resource_type: 'Host'
 
     permission :view_hosts,
-               { :'foreman_salt/minions' => [:node],
-                 :'foreman_salt/api/v2/salt_minions' => [:index, :show] },
-               :resource_type => 'Host'
-
-    permission :edit_hostgroups,
-               { :hostgroups => [:salt_environment_selected] },
-               :resource_type => 'Hostgroup'
+      { 'foreman_salt/minions': [:node],
+        'foreman_salt/api/v2/salt_minions': %i[index show] },
+      resource_type: 'Host'
 
     permission :view_smart_proxies_salt_keys,
-               { :'foreman_salt/salt_keys' => [:index],
-                 :'foreman_salt/api/v2/salt_keys' => [:index] },
-               :resource_type => 'SmartProxy'
+      { 'foreman_salt/salt_keys': [:index],
+        'foreman_salt/api/v2/salt_keys': [:index] },
+      resource_type: 'SmartProxy'
 
     permission :destroy_smart_proxies_salt_keys,
-               { :'foreman_salt/salt_keys' => [:destroy],
-                 :'foreman_salt/api/v2/salt_keys' => [:destroy] },
-               :resource_type => 'SmartProxy'
+      { 'foreman_salt/salt_keys': [:destroy],
+        'foreman_salt/api/v2/salt_keys': [:destroy] },
+      resource_type: 'SmartProxy'
 
     permission :edit_smart_proxies_salt_keys,
-               { :'foreman_salt/salt_keys' => [:accept, :reject],
-                 :'foreman_salt/api/v2/salt_keys' => [:update] },
-               :resource_type => 'SmartProxy'
+      { 'foreman_salt/salt_keys': %i[accept reject],
+        'foreman_salt/api/v2/salt_keys': [:update] },
+      resource_type: 'SmartProxy'
 
     permission :create_salt_modules,
-               { :'foreman_salt/salt_modules' => [:new, :create],
-                 :'foreman_salt/api/v2/salt_states' => [:create] },
-               :resource_type => 'ForemanSalt::SaltModule'
+      { 'foreman_salt/salt_modules': %i[new create],
+        'foreman_salt/api/v2/salt_states': [:create] },
+      resource_type: 'ForemanSalt::SaltModule'
 
     permission :import_salt_modules,
-               { :'foreman_salt/salt_modules' => [:import, :apply_changes],
-                 :'foreman_salt/api/v2/salt_states' => [:import] },
-               :resource_type => 'ForemanSalt::SaltModule'
+      { 'foreman_salt/salt_modules': %i[import apply_changes],
+        'foreman_salt/api/v2/salt_states': [:import] },
+      resource_type: 'ForemanSalt::SaltModule'
 
     permission :view_salt_modules,
-               { :'foreman_salt/salt_modules' => [:index, :show, :auto_complete_search],
-                 :'foreman_salt/api/v2/salt_states' => [:index, :show] },
-               :resource_type => 'ForemanSalt::SaltModule'
+      { 'foreman_salt/salt_modules': %i[index show auto_complete_search],
+        'foreman_salt/api/v2/salt_states': %i[index show] },
+      resource_type: 'ForemanSalt::SaltModule'
 
     permission :edit_salt_modules,
-               { :'foreman_salt/salt_modules' => [:update, :edit] },
-               :resource_type => 'ForemanSalt::SaltModule'
+      { 'foreman_salt/salt_modules': %i[update edit] },
+      resource_type: 'ForemanSalt::SaltModule'
 
     permission :destroy_salt_modules,
-               { :'foreman_salt/salt_modules' => [:destroy],
-                 :'foreman_salt/api/v2/salt_states' => [:destroy] },
-               :resource_type => 'ForemanSalt::SaltModule'
+      { 'foreman_salt/salt_modules': [:destroy],
+        'foreman_salt/api/v2/salt_states': [:destroy] },
+      resource_type: 'ForemanSalt::SaltModule'
   end
 
   # Roles
-  role 'Salt admin', [:saltrun_hosts,
-                      :create_salt_modules, :view_salt_modules,
-                      :edit_salt_modules, :destroy_salt_modules,
-                      :import_salt_modules,
-                      :view_smart_proxies_salt_keys,
-                      :edit_smart_proxies_salt_keys, :destroy_smart_proxies_salt_keys,
-                      :create_smart_proxies_salt_autosign, :view_smart_proxies_salt_autosign,
-                      :destroy_smart_proxies_salt_autosign,
-                      :create_salt_environments, :view_salt_environments,
-                      :edit_salt_environments, :destroy_salt_environments,
-                      :create_salt_variables, :view_salt_variables,
-                      :edit_salt_variables, :destroy_salt_variables]
-
-  role 'Salt viewer', [:view_smart_proxies_salt_keys,
-                       :view_smart_proxies_salt_autosign,
-                       :view_salt_variables,
-                       :view_salt_environments,
-                       :view_salt_modules]
+  role 'Salt admin', %i[saltrun_hosts
+                        create_salt_modules view_salt_modules
+                        edit_salt_modules destroy_salt_modules
+                        import_salt_modules
+                        view_smart_proxies_salt_keys
+                        edit_smart_proxies_salt_keys destroy_smart_proxies_salt_keys
+                        create_smart_proxies_salt_autosign view_smart_proxies_salt_autosign
+                        destroy_smart_proxies_salt_autosign auth_smart_proxies_salt_autosign
+                        create_salt_environments view_salt_environments
+                        edit_salt_environments destroy_salt_environments
+                        create_salt_variables view_salt_variables
+                        edit_salt_variables destroy_salt_variables
+                        view_hostgroups edit_hostgroups]
+
+  role 'Salt viewer', %i[view_smart_proxies_salt_keys
+                         view_smart_proxies_salt_autosign
+                         view_salt_variables
+                         view_salt_environments
+                         view_salt_modules
+                         view_hostgroups]
 
   # Parameter filters
   parameter_filter Hostgroup,
-                   :salt_proxy_id, :salt_proxy_name, :salt_environment_id,
-                   :salt_environment_name, :salt_modules => [], :salt_module_ids => []
+    :salt_proxy_id, :salt_proxy_name, :salt_environment_id,
+    :salt_environment_name, salt_modules: [], salt_module_ids: []
   parameter_filter Host::Managed,
-                   :salt_proxy_id, :salt_proxy_name,
-                   :salt_environment_id, :salt_environment_name, :salt_modules => [],
-                   :salt_module_ids => []
+    :salt_proxy_id, :salt_proxy_name,
+    :salt_environment_id, :salt_environment_name, salt_modules: [],
+                                                  salt_module_ids: []
 end
-# rubocop:enable BlockLength

data/lib/foreman_salt/version.rb

@@ -1,3 +1,3 @@
 module ForemanSalt
-  VERSION = '14.0.0'
+  VERSION = '15.1.0'.freeze
 end

data/lib/foreman_salt.rb

@@ -3,7 +3,7 @@ require 'foreman_salt/engine'
 begin
   require 'foreman-tasks'
 rescue LoadError
-  puts 'ForemanTasks is not available, async tasks disabled.'
+  Rails.logger.error('ForemanSalt: ForemanTasks is not available, async tasks disabled.')
 end
 
 module ForemanSalt

data/lib/tasks/foreman_salt_tasks.rake

@@ -1,5 +1,5 @@
 namespace :foreman_salt do
-  task :rubocop do
+  task rubocop: :environment do
     begin
       require 'rubocop/rake_task'
       RuboCop::RakeTask.new(:rubocop_salt) do |task|
@@ -7,7 +7,7 @@ namespace :foreman_salt do
                          "#{ForemanSalt::Engine.root}/lib/**/*.rb",
                          "#{ForemanSalt::Engine.root}/test/**/*.rb"]
       end
-    rescue
+    rescue StandardError
       puts 'Rubocop not loaded.'
     end
 
@@ -29,6 +29,4 @@ end
 Rake::Task[:test].enhance ['test:foreman_salt']
 
 load 'tasks/jenkins.rake'
-if Rake::Task.task_defined?(:'jenkins:unit')
-  Rake::Task['jenkins:unit'].enhance ['test:foreman_salt', 'foreman_salt:rubocop']
-end
+Rake::Task['jenkins:unit'].enhance ['test:foreman_salt', 'foreman_salt:rubocop'] if Rake::Task.task_defined?(:'jenkins:unit')

data/locale/action_names.rb

@@ -1,5 +1,5 @@
 # Autogenerated!
-_("Action with sub plans")
-_("Import facts")
-_("Import Puppet classes")
-_("Remote action:")
+_('Action with sub plans')
+_('Import facts')
+_('Import Puppet classes')
+_('Remote action:')

data/test/factories/foreman_salt_factories.rb

@@ -1,13 +1,13 @@
 FactoryBot.define do
-  factory :salt_module, :class => 'ForemanSalt::SaltModule' do
+  factory :salt_module, class: 'ForemanSalt::SaltModule' do
     sequence(:name) { |n| "module#{n}" }
   end
 
-  factory :salt_environment, :class => 'ForemanSalt::SaltEnvironment' do
+  factory :salt_environment, class: 'ForemanSalt::SaltEnvironment' do
     sequence(:name) { |n| "environment#{n}" }
   end
 
-  factory :salt_variable, :class => 'ForemanSalt::SaltVariable' do
+  factory :salt_variable, class: 'ForemanSalt::SaltVariable' do
     sequence(:key) { |n| "salt_variable_#{n}" }
     sequence(:default_value) { |n| "default_value_#{n}" }
     salt_module
@@ -18,13 +18,13 @@ FactoryBot.modify do
   factory :hostgroup do
     trait :with_salt_modules do
       salt_environment { FactoryBot.build :salt_environment }
-      salt_modules { FactoryBot.create_list :salt_module, 10, :salt_environments => [self.salt_environment] }
+      salt_modules { FactoryBot.create_list :salt_module, 10, salt_environments: [salt_environment] }
     end
   end
 
   factory :smart_proxy do
     trait :with_salt_feature do
-      features { [::Feature.find_or_create_by(:name => 'Salt')] }
+      features { [::Feature.find_or_create_by(name: 'Salt')] }
     end
   end
 end

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

@@ -1,27 +1,33 @@
 require 'test_plugin_helper'
 
-class ::ForemanSalt::Api::V2::SaltAutosignControllerTest < ActionController::TestCase
-  setup do
-    @proxy = FactoryBot.create(:smart_proxy, :with_salt_feature)
-    @host = FactoryBot.create(:host, :managed)
-    @host.salt_proxy = @proxy
-    ProxyAPI::Salt.any_instance.stubs(:autosign_list).returns((%w(foo bar baz)))
-  end
+module ForemanSalt
+  module Api
+    module V2
+      class SaltAutosignControllerTest < ActionController::TestCase
+        setup do
+          @proxy = FactoryBot.create(:smart_proxy, :with_salt_feature)
+          @host = FactoryBot.create(:host, :managed)
+          @host.salt_proxy = @proxy
+          ProxyAPI::Salt.any_instance.stubs(:autosign_list).returns(%w[foo bar baz])
+        end
 
-  test 'should get index' do
-    get :index, params: { :smart_proxy_id => @proxy.id }
-    assert_response :success
-  end
+        test 'should get index' do
+          get :index, params: { smart_proxy_id: @proxy.id }
+          assert_response :success
+        end
 
-  test 'should create autosign' do
-    ProxyAPI::Salt.any_instance.expects(:autosign_create).once.returns(true)
-    post :create, params: { :smart_proxy_id => @proxy.id, :record => 'unicorn.example.com' }
-    assert_response :success
-  end
+        test 'should create autosign' do
+          ProxyAPI::Salt.any_instance.expects(:autosign_create).once.returns(true)
+          post :create, params: { smart_proxy_id: @proxy.id, record: 'unicorn.example.com' }
+          assert_response :success
+        end
 
-  test 'should delete autosign' do
-    ProxyAPI::Salt.any_instance.expects(:autosign_remove).once.returns(true)
-    delete :destroy, params: { :smart_proxy_id => @proxy.id, :record => 'unicorn.example.com' }
-    assert_response :success
+        test 'should delete autosign' do
+          ProxyAPI::Salt.any_instance.expects(:autosign_remove).once.returns(true)
+          delete :destroy, params: { smart_proxy_id: @proxy.id, record: 'unicorn.example.com' }
+          assert_response :success
+        end
+      end
+    end
   end
 end