foreman_salt 14.0.0 → 14.1.0

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

@@ -0,0 +1,76 @@
+require 'test_plugin_helper'
+
+module ForemanSalt
+  module Api
+    module V2
+      class SaltHostgroupsControllerTest < ActionController::TestCase
+        setup do
+          @proxy = FactoryBot.create(:smart_proxy, :with_salt_feature)
+          @env = ForemanSalt::SaltEnvironment.create(name: 'basement')
+          @state = ForemanSalt::SaltModule.create(name: 'motd')
+        end
+
+        test 'should show host group' do
+          hostgroup = FactoryBot.create(:hostgroup)
+          get :show, params: { id: hostgroup.id }
+
+          assert_response :success
+          assert_template 'foreman_salt/api/v2/salt_hostgroups/show'
+        end
+
+        test 'should set proxy' do
+          hostgroup = FactoryBot.create(:hostgroup)
+          put :update, params: { id: hostgroup.id, hostgroup: { salt_proxy_id: @proxy.id } }
+          response_json = ActiveSupport::JSON.decode(response.body)
+          # remove protocol and port
+          clean_url = @proxy.url[8..-6]
+
+          assert_response :success
+          assert_template 'foreman_salt/api/v2/salt_hostgroups/update'
+          assert_equal clean_url, response_json['salt_master']
+        end
+
+        test 'should not find proxy' do
+          hostgroup = FactoryBot.create(:hostgroup)
+          put :update, params: { id: hostgroup.id, hostgroup: { salt_proxy_id: -2 } }
+
+          assert_response 422 # unprocessable entity
+        end
+
+        test 'should set environment' do
+          hostgroup = FactoryBot.create(:hostgroup)
+          put :update, params: { id: hostgroup.id, hostgroup: { salt_environment_id: @env.id } }
+          response_json = ActiveSupport::JSON.decode(response.body)
+
+          assert_response :success
+          assert_template 'foreman_salt/api/v2/salt_hostgroups/update'
+          assert_equal @env.name, response_json['salt_environment']
+        end
+
+        test 'should not find environment' do
+          hostgroup = FactoryBot.create(:hostgroup)
+          put :update, params: { id: hostgroup.id, hostgroup: { salt_environment_id: -12 } }
+
+          assert_response 422 # unprocessable entity
+        end
+
+        test 'should set states' do
+          hostgroup = FactoryBot.create(:hostgroup)
+          put :update, params: { id: hostgroup.id, hostgroup: { salt_state_ids: [@state.id] } }
+          response_json = ActiveSupport::JSON.decode(response.body)
+
+          assert_response :success
+          assert_template 'foreman_salt/api/v2/salt_hostgroups/update'
+          assert_equal @state.name, response_json['salt_states'][0]['name']
+        end
+
+        test 'should not find states' do
+          hostgroup = FactoryBot.create(:hostgroup)
+          put :update, params: { id: hostgroup.id, hostgroup: { salt_state_ids: [-5] } }
+
+          assert_response 422 # unprocessable entity
+        end
+      end
+    end
+  end
+end

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

@@ -1,27 +1,33 @@
 require 'test_plugin_helper'
 
-class ::ForemanSalt::Api::V2::SaltKeysControllerTest < ActionController::TestCase
-  setup do
-    @proxy = FactoryBot.create(:smart_proxy, :with_salt_feature)
+module ForemanSalt
+  module Api
+    module V2
+      class SaltKeysControllerTest < ActionController::TestCase
+        setup do
+          @proxy = FactoryBot.create(:smart_proxy, :with_salt_feature)
 
-    ProxyAPI::Salt.any_instance.stubs(:key_list).returns('saltstack.example.com' => { 'state' => 'unaccepted',
-                                                                                      'fingerprint' => '98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c0' })
-  end
+          ProxyAPI::Salt.any_instance.stubs(:key_list).returns('saltstack.example.com' => { 'state' => 'unaccepted',
+                                                                                            'fingerprint' => '98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c0' })
+        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 update keys' do
-    ProxyAPI::Salt.any_instance.expects(:key_accept).once.returns(true)
-    put :update, params: { :smart_proxy_id => @proxy.id, :name => 'saltstack.example.com', :state => 'accepted' }
-    assert_response :success
-  end
+        test 'should update keys' do
+          ProxyAPI::Salt.any_instance.expects(:key_accept).once.returns(true)
+          put :update, params: { smart_proxy_id: @proxy.id, name: 'saltstack.example.com', state: 'accepted' }
+          assert_response :success
+        end
 
-  test 'should delete keys' do
-    ProxyAPI::Salt.any_instance.expects(:key_delete).once.returns(true)
-    delete :destroy, params: { :smart_proxy_id => @proxy.id, :name => 'saltstack.example.com' }
-    assert_response :success
+        test 'should delete keys' do
+          ProxyAPI::Salt.any_instance.expects(:key_delete).once.returns(true)
+          delete :destroy, params: { smart_proxy_id: @proxy.id, name: 'saltstack.example.com' }
+          assert_response :success
+        end
+      end
+    end
   end
 end

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

@@ -1,84 +1,90 @@
 require 'test_plugin_helper'
 
-class ::ForemanSalt::Api::V2::SaltStatesControllerTest < ActionController::TestCase
-  test 'should get index' do
-    get :index
-    assert_response :success
-    assert_template 'api/v2/salt_states/index'
-  end
+module ForemanSalt
+  module Api
+    module V2
+      class SaltStatesControllerTest < ActionController::TestCase
+        test 'should get index' do
+          get :index
+          assert_response :success
+          assert_template 'api/v2/salt_states/index'
+        end
 
-  test 'should show state' do
-    state = ForemanSalt::SaltModule.create(:name => 'foo.bar.baz')
-    get :show, params: { :id => state.id }
-    assert_response :success
-    assert_template 'api/v2/salt_states/show'
-  end
+        test 'should show state' do
+          state = ForemanSalt::SaltModule.create(name: 'foo.bar.baz')
+          get :show, params: { id: state.id }
+          assert_response :success
+          assert_template 'api/v2/salt_states/show'
+        end
 
-  test 'should create state' do
-    post :create, params: { :state => { :name => 'unicorn' } }
-    assert_response :success
-    assert ForemanSalt::SaltModule.find_by_name('unicorn')
-    assert_template 'api/v2/salt_states/create'
-  end
+        test 'should create state' do
+          post :create, params: { state: { name: 'unicorn' } }
+          assert_response :success
+          assert ForemanSalt::SaltModule.find_by(name: 'unicorn')
+          assert_template 'api/v2/salt_states/create'
+        end
 
-  test 'should delete state' do
-    state = ForemanSalt::SaltModule.create(:name => 'foo.bar.baz')
-    assert_difference('ForemanSalt::SaltModule.count', -1) do
-      delete :destroy, params: { :id => state.id }
-    end
-    assert_response :success
-  end
+        test 'should delete state' do
+          state = ForemanSalt::SaltModule.create(name: 'foo.bar.baz')
+          assert_difference('ForemanSalt::SaltModule.count', -1) do
+            delete :destroy, params: { id: state.id }
+          end
+          assert_response :success
+        end
 
-  context 'importing' do
-    setup do
-      @proxy = FactoryBot.create :smart_proxy, :with_salt_feature
-      @states = { 'env1' => %w(state1 state2 state3),
-                  'env2' => %w(state1 state2) }
+        context 'importing' do
+          setup do
+            @proxy = FactoryBot.create :smart_proxy, :with_salt_feature
+            @states = { 'env1' => %w[state1 state2 state3],
+                        'env2' => %w[state1 state2] }
 
-      ProxyAPI::Salt.any_instance.stubs(:states_list).returns(@states)
-    end
+            ProxyAPI::Salt.any_instance.stubs(:states_list).returns(@states)
+          end
 
-    test 'should import' do
-      post :import, params: { :smart_proxy_id => @proxy.id }
+          test 'should import' do
+            post :import, params: { smart_proxy_id: @proxy.id }
 
-      assert_response :success
+            assert_response :success
 
-      @states.each do |env, states|
-        environment = ::ForemanSalt::SaltEnvironment.find_by_name(env)
-        assert_empty environment.salt_modules.map(&:name) - states
-      end
-    end
+            @states.each do |env, states|
+              environment = ::ForemanSalt::SaltEnvironment.find_by(name: env)
+              assert_empty environment.salt_modules.map(&:name) - states
+            end
+          end
 
-    test 'should import only from a given environment' do
-      post :import, params: { :smart_proxy_id => @proxy.id, :salt_environments => ['env2'] }
-      assert_response :success
-      assert_not ::ForemanSalt::SaltEnvironment.where(:name => 'env1').first
-      assert ::ForemanSalt::SaltEnvironment.where(:name => 'env2').first
-    end
+          test 'should import only from a given environment' do
+            post :import, params: { smart_proxy_id: @proxy.id, salt_environments: ['env2'] }
+            assert_response :success
+            assert_not ::ForemanSalt::SaltEnvironment.where(name: 'env1').first
+            assert ::ForemanSalt::SaltEnvironment.where(name: 'env2').first
+          end
 
-    test 'should limit actions to add' do
-      env   = FactoryBot.create :salt_environment
-      state = FactoryBot.create :salt_module, :salt_environments => [env]
+          test 'should limit actions to add' do
+            env   = FactoryBot.create :salt_environment
+            state = FactoryBot.create :salt_module, salt_environments: [env]
 
-      post :import, params: { :smart_proxy_id => @proxy.id, :actions => ['add'] }
-      assert_response :success
-      assert ::ForemanSalt::SaltModule.where(:id => state).first
-      assert ::ForemanSalt::SaltModule.where(:name => 'state1').first
-    end
+            post :import, params: { smart_proxy_id: @proxy.id, actions: ['add'] }
+            assert_response :success
+            assert ::ForemanSalt::SaltModule.where(id: state).first
+            assert ::ForemanSalt::SaltModule.where(name: 'state1').first
+          end
 
-    test 'should limit actions to remove' do
-      state = FactoryBot.create :salt_module
-      post :import, params: { :smart_proxy_id => @proxy.id, :actions => ['remove'] }
-      assert_response :success
-      assert_not ::ForemanSalt::SaltModule.where(:id => state).first
-      assert_not ::ForemanSalt::SaltModule.where(:name => 'state1').first
-    end
+          test 'should limit actions to remove' do
+            state = FactoryBot.create :salt_module
+            post :import, params: { smart_proxy_id: @proxy.id, actions: ['remove'] }
+            assert_response :success
+            assert_not ::ForemanSalt::SaltModule.where(id: state).first
+            assert_not ::ForemanSalt::SaltModule.where(name: 'state1').first
+          end
 
-    test 'dryrun should do nothing' do
-      post :import, params: { :smart_proxy_id => @proxy.id, :dryrun => true }
-      assert_response :success
-      assert_not ::ForemanSalt::SaltModule.all.any?
-      assert_not ::ForemanSalt::SaltEnvironment.all.any?
+          test 'dryrun should do nothing' do
+            post :import, params: { smart_proxy_id: @proxy.id, dryrun: true }
+            assert_response :success
+            assert_not ::ForemanSalt::SaltModule.all.any?
+            assert_not ::ForemanSalt::SaltEnvironment.all.any?
+          end
+        end
+      end
     end
   end
 end

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

@@ -12,21 +12,21 @@ module ForemanSalt
         end
 
         test 'should get index' do
-          get :index, :session => set_session_user
+          get :index, session: set_session_user
           response = JSON.parse(@response.body)
           assert_not_empty response['results']
           assert_response :success
         end
 
         test 'should destroy' do
-          delete :destroy, :params => { :id => @variable.id }, :session => set_session_user
+          delete :destroy, params: { id: @variable.id }, session: set_session_user
           assert_response :ok
           assert_not SaltVariable.exists?(@variable.id)
         end
 
         test 'should create' do
-          params = { :key => 'test name', :salt_state_id => FactoryBot.create(:salt_module).id }
-          post :create, :params => params, :session => set_session_user
+          params = { key: 'test name', salt_state_id: FactoryBot.create(:salt_module).id }
+          post :create, params: params, session: set_session_user
           assert_response :success
         end
       end

data/test/functional/hosts_controller_test.rb

@@ -4,9 +4,9 @@ module ForemanSalt
   class HostsControllerExtensionsTest < ActionController::TestCase
     tests ::HostsController
 
-    describe "setting salt master proxy on multiple hosts" do
+    describe 'setting salt master proxy on multiple hosts' do
       before do
-        setup_user "edit"
+        setup_user 'edit'
         as_admin do
           @hosts = FactoryBot.create_list(:host, 2)
           @proxy = FactoryBot.create(:smart_proxy, :with_salt_feature)
@@ -16,22 +16,22 @@ module ForemanSalt
       test 'user without edit permission should not be able to change salt master' do
         @request.env['HTTP_REFERER'] = hosts_path
 
-        params = { :host_ids => @hosts.map(&:id),
-                   :proxy => { :proxy_id => '' } }
+        params = { host_ids: @hosts.map(&:id),
+                   proxy: { proxy_id: '' } }
 
         post :update_multiple_salt_master, params: params,
-          session: set_session_user.merge(:user => users(:one).id)
+                                           session: set_session_user.merge(user: users(:one).id)
         assert_response :forbidden
       end
 
-      test "should change the salt master proxy" do
+      test 'should change the salt master proxy' do
         @request.env['HTTP_REFERER'] = hosts_path
 
-        params = { :host_ids => @hosts.map(&:id),
-                   :proxy => { :proxy_id => @proxy.id } }
+        params = { host_ids: @hosts.map(&:id),
+                   proxy: { proxy_id: @proxy.id } }
 
         post :update_multiple_salt_master, params: params,
-        session: set_session_user.merge(:user => users(:admin).id)
+                                           session: set_session_user.merge(user: users(:admin).id)
 
         assert_empty flash[:error]
 
@@ -42,14 +42,14 @@ module ForemanSalt
         end
       end
 
-      test "should clear the salt master proxy of multiple hosts" do
+      test 'should clear the salt master proxy of multiple hosts' do
         @request.env['HTTP_REFERER'] = hosts_path
 
-        params = { :host_ids => @hosts.map(&:id),
-                   :proxy => { :proxy_id => '' } }
+        params = { host_ids: @hosts.map(&:id),
+                   proxy: { proxy_id: '' } }
 
         post :update_multiple_salt_master, params: params,
-          session: set_session_user.merge(:user => users(:admin).id)
+                                           session: set_session_user.merge(user: users(:admin).id)
 
         assert_empty flash[:error]
 
@@ -61,9 +61,9 @@ module ForemanSalt
       end
     end
 
-    describe "setting salt environment on multiple hosts" do
+    describe 'setting salt environment on multiple hosts' do
       before do
-        setup_user "edit"
+        setup_user 'edit'
         as_admin do
           @hosts = FactoryBot.create_list(:host, 2)
           @proxy = FactoryBot.create(:smart_proxy, :with_salt_feature)
@@ -74,22 +74,22 @@ module ForemanSalt
       test 'user without edit permission should not be able to change salt environment' do
         @request.env['HTTP_REFERER'] = hosts_path
 
-        params = { :host_ids => @hosts.map(&:id),
-                   :salt_environment => { :id => @salt_environment.id } }
+        params = { host_ids: @hosts.map(&:id),
+                   salt_environment: { id: @salt_environment.id } }
 
         post :update_multiple_salt_environment, params: params,
-        session: set_session_user.merge(:user => users(:one).id)
+                                                session: set_session_user.merge(user: users(:one).id)
         assert_response :forbidden
       end
 
-      test "should change the salt environment" do
+      test 'should change the salt environment' do
         @request.env['HTTP_REFERER'] = hosts_path
 
-        params = { :host_ids => @hosts.map(&:id),
-                   :salt_environment => { :id => @salt_environment.id } }
+        params = { host_ids: @hosts.map(&:id),
+                   salt_environment: { id: @salt_environment.id } }
 
         post :update_multiple_salt_environment, params: params,
-        session: set_session_user.merge(:user => users(:admin).id)
+                                                session: set_session_user.merge(user: users(:admin).id)
 
         assert_empty flash[:error]
 
@@ -100,14 +100,14 @@ module ForemanSalt
         end
       end
 
-      test "should clear the salt environment of multiple hosts" do
+      test 'should clear the salt environment of multiple hosts' do
         @request.env['HTTP_REFERER'] = hosts_path
 
-        params = { :host_ids => @hosts.map(&:id),
-                   :salt_environment => { :id => '' } }
+        params = { host_ids: @hosts.map(&:id),
+                   salt_environment: { id: '' } }
 
         post :update_multiple_salt_environment, params: params,
-          session: set_session_user.merge(:user => users(:admin).id)
+                                                session: set_session_user.merge(user: users(:admin).id)
 
         assert_empty flash[:error]
 

data/test/functional/minions_controller_test.rb

@@ -13,26 +13,26 @@ module ForemanSalt
 
       @hostgroup = FactoryBot.create(:hostgroup)
       @host = FactoryBot.create(:host, salt_environment: FactoryBot.create(:salt_environment), salt_proxy: @proxy)
-      @host2 = FactoryBot.create(:host, :hostgroup => @hostgroup, salt_environment: FactoryBot.create(:salt_environment), salt_proxy: @proxy)
-      FactoryBot.create(:host_parameter, name: "parameter1", value: "different", host: @host)
+      @host2 = FactoryBot.create(:host, hostgroup: @hostgroup, salt_environment: FactoryBot.create(:salt_environment), salt_proxy: @proxy)
+      FactoryBot.create(:host_parameter, name: 'parameter1', value: 'different', host: @host)
     end
 
     test 'salt smart proxy should get salt external node' do
-      get :node, params: { :id => @host, :format => 'yml' }
+      get :node, params: { id: @host, format: 'yml' }
       assert_response :success
 
       res = YAML.safe_load(@response.body)
-      assert_equal res['parameters']['parameter1'], 'different'
+      assert_equal('different', res['parameters']['parameter1'])
     end
 
     test 'setting salt_namespace_pillars is considered' do
       Setting['salt_namespace_pillars'] = true
 
-      get :node, params: { :id => @host, :format => 'yml' }
+      get :node, params: { id: @host, format: 'yml' }
       assert_response :success
 
       res = YAML.safe_load(@response.body)
-      assert_equal res['parameters']['foreman']['parameter1'], 'different'
+      assert_equal('different', res['parameters']['foreman']['parameter1'])
     end
 
     test 'salt variable is available' do
@@ -40,7 +40,7 @@ module ForemanSalt
       var.salt_module.salt_environments << @host.salt_environment
       @host.salt_modules << var.salt_module
 
-      get :node, params: { :id => @host, :format => 'yml' }
+      get :node, params: { id: @host, format: 'yml' }
       assert_response :success
 
       res = YAML.safe_load(@response.body)
@@ -52,7 +52,7 @@ module ForemanSalt
       var.salt_module.salt_environments << @host.salt_environment
       @host.salt_modules << var.salt_module
 
-      get :node, params: { :id => @host, :format => 'yml' }
+      get :node, params: { id: @host, format: 'yml' }
       assert_response :success
 
       res = YAML.safe_load(@response.body)
@@ -60,17 +60,17 @@ module ForemanSalt
     end
 
     test 'salt variable matching host with host specific value' do
-      var = FactoryBot.create(:salt_variable, key: 'parameter1', value: "default", override: true)
+      var = FactoryBot.create(:salt_variable, key: 'parameter1', value: 'default', override: true)
       # rubocop:disable Lint/UselessAssignment
-      value1 = LookupValue.create(:lookup_key => var, :match => "os=debian", :value => "aaa")
-      value2 = LookupValue.create(:lookup_key => var, :match => "fqdn=#{@host.fqdn}", :value => "myval")
-      value3 = LookupValue.create(:lookup_key => var, :match => "hostgroup=Unusual", :value => "bbbb")
+      value1 = LookupValue.create(lookup_key: var, match: 'os=debian', value: 'aaa')
+      value2 = LookupValue.create(lookup_key: var, match: "fqdn=#{@host.fqdn}", value: 'myval')
+      value3 = LookupValue.create(lookup_key: var, match: 'hostgroup=Unusual', value: 'bbbb')
       # rubocop:enable Lint/UselessAssignment
 
       var.salt_module.salt_environments << @host.salt_environment
       @host.salt_modules << var.salt_module
 
-      get :node, params: { :id => @host, :format => 'yml' }
+      get :node, params: { id: @host, format: 'yml' }
       assert_response :success
 
       res = YAML.safe_load(@response.body)
@@ -78,16 +78,16 @@ module ForemanSalt
     end
 
     test 'salt variable matching host with hostgroup specific value' do
-      var = FactoryBot.create(:salt_variable, key: 'parameter1', value: "default", override: true)
+      var = FactoryBot.create(:salt_variable, key: 'parameter1', value: 'default', override: true)
       # rubocop:disable Lint/UselessAssignment
-      value1 = LookupValue.create(:lookup_key => var, :match => "os=debian", :value => "aaa")
-      value2 = LookupValue.create(:lookup_key => var, :match => @hostgroup.lookup_value_matcher, :value => "bbbb")
+      value1 = LookupValue.create(lookup_key: var, match: 'os=debian', value: 'aaa')
+      value2 = LookupValue.create(lookup_key: var, match: @hostgroup.lookup_value_matcher, value: 'bbbb')
       # rubocop:enable Lint/UselessAssignment
 
       var.salt_module.salt_environments << @host2.salt_environment
       @host2.salt_modules << var.salt_module
 
-      get :node, params: { :id => @host2, :format => 'yml' }
+      get :node, params: { id: @host2, format: 'yml' }
       assert_response :success
 
       res = YAML.safe_load(@response.body)
@@ -95,16 +95,16 @@ module ForemanSalt
     end
 
     test 'salt variable matching host with default value' do
-      var = FactoryBot.create(:salt_variable, key: 'parameter1', value: "default", override: true)
+      var = FactoryBot.create(:salt_variable, key: 'parameter1', value: 'default', override: true)
       # rubocop:disable Lint/UselessAssignment
-      value1 = LookupValue.create(:lookup_key => var, :match => "os=debian", :value => "aaa")
-      value2 = LookupValue.create(:lookup_key => var, :match => "fqdn=#{@host.fqdn}", :value => "myval")
-      value3 = LookupValue.create(:lookup_key => var, :match => "hostgroup=Unusual", :value => "bbbb")
+      value1 = LookupValue.create(lookup_key: var, match: 'os=debian', value: 'aaa')
+      value2 = LookupValue.create(lookup_key: var, match: "fqdn=#{@host.fqdn}", value: 'myval')
+      value3 = LookupValue.create(lookup_key: var, match: 'hostgroup=Unusual', value: 'bbbb')
       # rubocop:enable Lint/UselessAssignment
 
       var.salt_module.salt_environments << @host2.salt_environment
       @host2.salt_modules << var.salt_module
-      get :node, params: { :id => @host2, :format => 'yml' }
+      get :node, params: { id: @host2, format: 'yml' }
       assert_response :success
 
       res = YAML.safe_load(@response.body)

data/test/functional/salt_modules_controller_test.rb

@@ -8,13 +8,13 @@ module ForemanSalt
       @model = FactoryBot.create(:salt_module)
     end
 
-    basic_index_test "salt_modules"
+    basic_index_test 'salt_modules'
     basic_new_test
-    basic_edit_test "salt_module"
+    basic_edit_test 'salt_module'
 
     test 'should destroy module' do
       assert_difference('SaltModule.count', -1) do
-        delete :destroy, :params => { :id => @model.id }, :session => set_session_user
+        delete :destroy, params: { id: @model.id }, session: set_session_user
       end
       assert_redirected_to salt_modules_url
     end

data/test/functional/salt_variables_controller_test.rb

@@ -9,23 +9,23 @@ module ForemanSalt
       @proxy = FactoryBot.create(:smart_proxy, :with_salt_feature)
     end
 
-    basic_index_test "salt_variables"
+    basic_index_test 'salt_variables'
     basic_new_test
-    basic_edit_test "salt_variable"
+    basic_edit_test 'salt_variable'
     basic_pagination_per_page_test
     basic_pagination_rendered_test
 
     test 'should destroy variable' do
       assert_difference('SaltVariable.count', -1) do
-        delete :destroy, :params => { :id => @model.id }, :session => set_session_user
+        delete :destroy, params: { id: @model.id }, session: set_session_user
       end
       assert_redirected_to salt_variables_url
     end
 
     test 'should create salt variable' do
-      params = { :foreman_salt_salt_variable => { :key => 'great name', :salt_module_id => FactoryBot.create(:salt_module).id } }
+      params = { foreman_salt_salt_variable: { key: 'great name', salt_module_id: FactoryBot.create(:salt_module).id } }
       assert_difference('SaltVariable.count', 1) do
-        post :create, :params => params, :session => set_session_user
+        post :create, params: params, session: set_session_user
       end
       assert_redirected_to salt_variables_url
     end