foreman_puppet 0.0.1

data/test/controllers/foreman_puppet/api/v2/hostgroups_controller_test.rb

@@ -0,0 +1,79 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  module Api
+    module V2
+      class HostgroupsControllerTest < ActionController::TestCase
+        tests ::Api::V2::HostgroupsController
+
+        let(:hostgroup) { FactoryBot.create(:hostgroup, :with_puppet_enc, :with_puppetclass, :with_config_group) }
+        let(:non_puppet) { FactoryBot.create(:hostgroup, ptable: templates(:autopart)) }
+        let(:inherited) { FactoryBot.create(:hostgroup, :with_puppet_enc, parent: non_puppet) }
+
+        describe '#show' do
+          test 'includes puppetclasses under puppet node' do
+            get :show, params: { id: hostgroup.to_param }
+            assert_response :success
+            json_response = ActiveSupport::JSON.decode(response.body)
+            assert json_response['puppet']['puppetclasses'].is_a? Array
+            response_pg_ids = json_response['puppet']['puppetclasses'].map { |pg| pg['id'] }
+            assert_equal hostgroup.puppet.puppetclasses.pluck(:id), response_pg_ids
+          end
+
+          test 'include config_groups under puppet node' do
+            get :show, params: { id: hostgroup.to_param }
+            assert_response :success
+            json_response = ActiveSupport::JSON.decode(response.body)
+            assert json_response['puppet']['config_groups'].is_a? Array
+            response_cg_ids = json_response['puppet']['config_groups'].map { |cg| cg['id'] }
+            assert_equal hostgroup.puppet.config_groups.pluck(:id), response_cg_ids
+          end
+
+          test 'include all_puppet clases for individual record under puppet node' do
+            get :show, params: { id: hostgroup.id }
+            assert_response :success
+            show_response = ActiveSupport::JSON.decode(response.body)
+            assert_not show_response.empty?
+            assert_not_equal 0, show_response['puppet']['all_puppetclasses'].length
+          end
+
+          test 'includes puppetclasses for backward compatibility' do
+            get :show, params: { id: hostgroup.to_param }
+            assert_response :success
+            json_response = ActiveSupport::JSON.decode(response.body)
+            assert json_response['puppetclasses'].is_a? Array
+            response_pg_ids = json_response['puppetclasses'].map { |pg| pg['id'] }
+            assert_equal hostgroup.puppet.puppetclasses.pluck(:id), response_pg_ids
+          end
+
+          test 'include config_groups for backward compatibility' do
+            get :show, params: { id: hostgroup.to_param }
+            assert_response :success
+            json_response = ActiveSupport::JSON.decode(response.body)
+            assert json_response['config_groups'].is_a? Array
+            response_cg_ids = json_response['config_groups'].map { |cg| cg['id'] }
+            assert_equal hostgroup.puppet.config_groups.pluck(:id), response_cg_ids
+          end
+
+          test 'include all_puppet clases for individual record' do
+            get :show, params: { id: hostgroup.id }
+            assert_response :success
+            show_response = ActiveSupport::JSON.decode(response.body)
+            assert_not show_response.empty?
+            assert_not_equal 0, show_response['all_puppetclasses'].length
+          end
+
+          test 'should show inherited parameters' do
+            get :show, params: { id: inherited.to_param }
+            assert_response :success
+            show_response = ActiveSupport::JSON.decode(@response.body)
+            assert_equal inherited.puppet.environment_id, show_response['environment_id']
+            assert_nil show_response['inherited_environment_id']
+            assert_nil show_response['ptable_id']
+            assert_equal templates(:autopart).id, show_response['inherited_ptable_id']
+          end
+        end
+      end
+    end
+  end
+end

data/test/controllers/foreman_puppet/api/v2/hosts_controller_test.rb

@@ -0,0 +1,101 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  module Api
+    module V2
+      class HostsControllerTest < ActionController::TestCase
+        tests ::Api::V2::HostsController
+
+        let(:host) { FactoryBot.create(:host, :with_puppet_enc) }
+        let(:environment) do
+          FactoryBot.create(:environment, :with_puppetclass, organizations: [host.organization], locations: [host.location])
+        end
+        let(:puppet_proxy) { FactoryBot.create(:puppet_smart_proxy) }
+
+        describe '#show' do
+          test 'includes config_groups under puppet node' do
+            get :show, params: { id: host.to_param }
+            assert_response :success
+            json_response = ActiveSupport::JSON.decode(response.body)
+            assert json_response['puppet']['config_groups'].is_a? Array
+            response_cg_ids = json_response['puppet']['config_groups'].map { |cg| cg['id'] }
+            assert_equal host.puppet.config_groups.pluck(:id), response_cg_ids
+          end
+
+          test 'includes puppetclasses under puppet node' do
+            get :show, params: { id: host.to_param }
+            assert_response :success
+            json_response = ActiveSupport::JSON.decode(response.body)
+            assert json_response['puppet']['puppetclasses'].is_a? Array
+            response_pg_ids = json_response['puppet']['puppetclasses'].map { |pg| pg['id'] }
+            assert_equal host.puppet.puppetclasses.pluck(:id), response_pg_ids
+          end
+
+          test 'includes config_groups for backward compatibility' do
+            get :show, params: { id: host.to_param }
+            assert_response :success
+            json_response = ActiveSupport::JSON.decode(response.body)
+            assert json_response['config_groups'].is_a? Array
+            response_cg_ids = json_response['config_groups'].map { |cg| cg['id'] }
+            assert_equal host.puppet.config_groups.pluck(:id), response_cg_ids
+          end
+
+          test 'includes puppetclasses for backward compatibility' do
+            get :show, params: { id: host.to_param }
+            assert_response :success
+            json_response = ActiveSupport::JSON.decode(response.body)
+            assert json_response['puppetclasses'].is_a? Array
+            response_pg_ids = json_response['puppetclasses'].map { |pg| pg['id'] }
+            assert_equal host.puppet.puppetclasses.pluck(:id), response_pg_ids
+          end
+
+          test 'should show host puppet_proxy_name' do
+            # cover issue #16525
+            host.update(puppet_proxy: puppet_proxy)
+            get :show, params: { id: host.to_param }
+            assert_response :success
+            json = ActiveSupport::JSON.decode(response.body)
+            assert json.key?('puppet_proxy_name')
+            assert_equal puppet_proxy.name, json['puppet_proxy_name']
+          end
+        end
+
+        describe '#create' do
+          test 'should create with puppet proxy' do
+            host_params = FactoryBot.attributes_for(:host, managed: false).merge(environment_id: environment.id, puppet_proxy_id: puppet_proxy.to_param)
+            post :create, params: { host: host_params }
+            assert_response :created
+            assert_equal puppet_proxy.name, JSON.parse(@response.body)['puppet_proxy']['name'], "Can't create host with puppet proxy #{puppet_proxy}"
+          end
+        end
+
+        describe '#update' do
+          test 'should update with puppet proxy' do
+            put :update, params: { id: host.id, host: host.attributes.merge(puppet_proxy_id: puppet_proxy.id) }
+            assert_response :success
+            assert_equal puppet_proxy['name'], JSON.parse(@response.body)['puppet_proxy']['name'], "Can't update host with puppet proxy #{puppet_proxy}"
+          end
+
+          test 'should update with puppet class' do
+            puppetclass = environment.puppetclasses.first
+            put :update, params: { id: host.id, host: { environment_id: environment.id, puppetclass_ids: [puppetclass.id] } }
+            assert_response :success
+            response = JSON.parse(@response.body)
+            assert_equal environment.id, response['environment_id'], "Can't update host with environment #{environment}"
+            assert_equal puppetclass.id, response['puppetclasses'][0]['id'], "Can't update host with puppetclass #{puppetclass}"
+          end
+        end
+
+        describe '#enc' do
+          test 'should get ENC values of host' do
+            get :enc, params: { id: host.to_param }
+            assert_response :success
+            response = ActiveSupport::JSON.decode(@response.body)
+            puppet_class = response['data']['classes'].keys
+            assert_equal host.puppetclasses.map(&:name), puppet_class
+          end
+        end
+      end
+    end
+  end
+end

data/test/controllers/foreman_puppet/api/v2/lookups_common_controller_test.rb

@@ -0,0 +1,29 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  module Api
+    module V2
+      class DummyLookupController < ForemanPuppet::Api::V2::LookupsCommonController
+        attr_accessor :params
+      end
+
+      class LookupsCommonControllerTest < ActiveSupport::TestCase
+        setup do
+          @dummy = DummyLookupController.new
+        end
+
+        test 'should cast default_value from smart class parameter' do
+          @dummy.params = { smart_class_parameter: { default_value: %w[a b] } }
+          @dummy.cast_value(:smart_class_parameter, :default_value)
+          assert_equal %w[a b].to_s, @dummy.params[:smart_class_parameter][:default_value]
+        end
+
+        test 'should cast value from override value' do
+          @dummy.params = { override_value: { value: 123 } }
+          @dummy.cast_value
+          assert_equal '123', @dummy.params[:override_value][:value]
+        end
+      end
+    end
+  end
+end

data/test/controllers/foreman_puppet/api/v2/override_values_controller_test.rb

@@ -0,0 +1,169 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  module Api
+    module V2
+      class OverrideValuesControllerTest < ActionController::TestCase
+        setup do
+          @routes = ForemanPuppet::Engine.routes
+          lookup_key
+        end
+
+        let(:lookup_key) { FactoryBot.create(:puppetclass_lookup_key, path: %w[hostgroup comment os].join("\n")) }
+        let(:lookup_value) { FactoryBot.create(:lookup_value, lookup_key: lookup_key, match: 'os=default') }
+
+        test 'should get override values for specific smart class parameter' do
+          lookup_value
+          FactoryBot.create(:lookup_value, lookup_key: lookup_key, match: 'comment=override')
+          get :index, params: { smart_class_parameter_id: lookup_key.to_param }
+          assert_response :success
+          override_values = ActiveSupport::JSON.decode(@response.body)
+          assert_not_empty override_values
+          assert_equal 2, override_values['results'].length
+        end
+
+        test 'should create override values for specific smart class parameter' do
+          assert_difference('LookupValue.count') do
+            post :create, params: { smart_class_parameter_id: lookup_key.to_param, override_value: { match: 'os=abc', value: 'liftoff' } }
+          end
+          assert_response :created
+        end
+
+        test 'should show specific override values for specific smart class parameter' do
+          get :show, params: { smart_class_parameter_id: lookup_key.to_param, id: lookup_value.id }
+          results = ActiveSupport::JSON.decode(@response.body)
+          assert_not_empty results
+          assert_equal 'os=default', results['match']
+          assert_response :success
+        end
+
+        test 'should show specific override values using match' do
+          get :show, params: { smart_class_parameter_id: lookup_key.to_param, id: lookup_value.match }
+          results = ActiveSupport::JSON.decode(@response.body)
+          assert_not_empty results
+          assert_equal 'os=default', results['match']
+          assert_response :success
+        end
+
+        test 'should update specific override value' do
+          put :update, params: { smart_class_parameter_id: lookup_key.to_param, id: lookup_value.id, override_value: { match: 'os=abc' } }
+          assert_response :success
+        end
+        test 'should update specific override value using match' do
+          put :update, params: { smart_class_parameter_id: lookup_key.to_param, id: lookup_value.match, override_value: { match: 'os=abc' } }
+          assert_response :success
+        end
+
+        test 'should destroy specific override value' do
+          lookup_value
+          assert_difference('LookupValue.count', -1) do
+            delete :destroy, params: { smart_class_parameter_id: lookup_key.to_param, id: lookup_value.id }
+          end
+          assert_response :success
+        end
+        test 'should destroy specific override value using match' do
+          lookup_value
+          assert_difference('LookupValue.count', -1) do
+            delete :destroy, params: { smart_class_parameter_id: lookup_key.to_param, id: lookup_value.match }
+          end
+          assert_response :success
+        end
+
+        [{ value: 'xyz=10' }, { match: 'os=string' }].each do |override_value|
+          test "should not create override value without #{override_value.keys.first}" do
+            assert_difference('LookupValue.count', 0) do
+              post :create, params: { smart_class_parameter_id: lookup_key.id, override_value: override_value }
+            end
+            response = ActiveSupport::JSON.decode(@response.body)
+            param_not_posted = (override_value.keys.first.to_s == 'match') ? 'Value' : 'Match' # The opposite of override_value is missing
+            assert_match(/Validation failed: #{param_not_posted} can't be blank/, response['error']['message'])
+            assert_response :error
+          end
+        end
+
+        test_attributes pid: '2b205e9c-e50c-48cd-8ebb-3b6bea09be77'
+        test 'should create override value without when omit is true' do
+          value = RFauxFactory.gen_alpha
+          assert_difference('LookupValue.count', 1) do
+            post :create, params: { smart_class_parameter_id: lookup_key.id, override_value: { match: 'os=string', value: value, omit: true } }
+          end
+          assert_response :success
+          lookup_key.reload
+          assert_equal('os=string', lookup_key.override_values.first.match)
+          assert_equal lookup_key.override_values.first.value, value
+          assert(lookup_key.override_values.first.omit)
+        end
+
+        test 'should not create override value without when omit is false' do
+          assert_difference('LookupValue.count', 0) do
+            post :create, params: { smart_class_parameter_id: lookup_key.id, override_value: { match: 'os=string', omit: false } }
+          end
+          assert_response :error
+        end
+
+        test_attributes pid: 'bef0e457-16be-4ca6-bc56-fa32dff55a01'
+        test 'should not create invalid matcher for non existing attribute' do
+          assert_difference('LookupValue.count', 0) do
+            post :create, params: { smart_class_parameter_id: lookup_key.id, override_value: { match: 'hostgroup=nonexistingHG', value: RFauxFactory.gen_alpha } }
+          end
+          assert_includes JSON.parse(response.body)['error']['message'], 'Validation failed: Match hostgroup=nonexistingHG does not match an existing host group'
+        end
+
+        test_attributes pid: '49de2c9b-40f1-4837-8ebb-dfa40d8fcb89'
+        test 'should not create matcher with blank matcher value' do
+          lookup_key.update(required: true)
+          assert_difference('LookupValue.count', 0) do
+            post :create, params: { smart_class_parameter_id: lookup_key.id, override_value: { match: 'os=string', value: '' } }
+          end
+          assert_includes JSON.parse(response.body)['error']['message'], "Validation failed: Value can't be blank"
+        end
+
+        test_attributes pid: '21668ef4-1a7a-41cb-98e3-dc4c664db351'
+        test 'should not create matcher with value that does not matches default type' do
+          lookup_key = FactoryBot.create(:puppetclass_lookup_key, :boolean)
+          assert_difference('LookupValue.count', 0) do
+            post :create, params: { smart_class_parameter_id: lookup_key.id, override_value: { match: 'os=string', value: RFauxFactory.gen_alpha } }
+          end
+          assert_includes JSON.parse(response.body)['error']['message'], 'Validation failed: Value is invalid'
+        end
+
+        test_attributes pid: '19d319e6-9b12-485e-a680-c84d18742c40'
+        test 'should create matcher for attribute in parameter' do
+          value = RFauxFactory.gen_alpha
+          lookup_key = FactoryBot.create(:puppetclass_lookup_key, override_value_order: 'is_virtual')
+          assert_difference('LookupValue.count') do
+            post :create, params: { smart_class_parameter_id: lookup_key.id, override_value: { match: 'is_virtual=true', value: value } }
+          end
+          lookup_key.reload
+          assert_equal('is_virtual=true', lookup_key.override_values.first.match)
+          assert_equal lookup_key.override_values.first.value, value
+        end
+
+        context 'hidden' do
+          let(:lookup_key) { FactoryBot.create(:puppetclass_lookup_key, hidden_value: true, default_value: 'hidden') }
+
+          test 'should show a override value as hidden unless show_hidden is true' do
+            get :show, params: { smart_class_parameter_id: lookup_key.to_param, id: lookup_value.to_param }
+            show_response = ActiveSupport::JSON.decode(@response.body)
+            assert_equal lookup_value.hidden_value, show_response['value']
+          end
+
+          test 'should show override value unhidden when show_hidden is true' do
+            get :show, params: { smart_class_parameter_id: lookup_key.to_param, id: lookup_value.to_param, show_hidden: 'true' }
+            show_response = ActiveSupport::JSON.decode(@response.body)
+            assert_equal lookup_value.value, show_response['value']
+          end
+
+          test 'should show a override value parameter as hidden when user in unauthorized for smart class variable' do
+            setup_user 'view', 'puppetclasses'
+            setup_user 'view', 'external_parameters'
+            setup_user 'edit', 'external_variables'
+            get :show, params: { smart_class_parameter_id: lookup_key.to_param, id: lookup_value.to_param, show_hidden: 'true' }
+            show_response = ActiveSupport::JSON.decode(@response.body)
+            assert_equal lookup_value.hidden_value, show_response['value']
+          end
+        end
+      end
+    end
+  end
+end

data/test/controllers/foreman_puppet/api/v2/puppetclasses_controller_test.rb

@@ -0,0 +1,144 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  module Api
+    module V2
+      class PuppetclassesControllerTest < ActionController::TestCase
+        let(:valid_attrs) { { name: 'PuppetClassValidName' } }
+
+        let(:default_organization) { Organization.first }
+        let(:default_location) { Location.first }
+        let(:environment) do
+          FactoryBot.create(:environment, locations: [default_location], organizations: [default_organization])
+        end
+        let(:puppetclass) { FactoryBot.create(:puppetclass, environments: [environment]) }
+        let(:eager_load) { puppetclass }
+
+        setup do
+          @routes = ForemanPuppet::Engine.routes
+          eager_load
+        end
+
+        test 'should get index' do
+          get :index
+          assert_response :success
+          assert_not json_response.empty?
+          assert json_response['results'].is_a?(Hash)
+        end
+
+        test 'should get index with style=list' do
+          get :index, params: { style: 'list' }
+          assert_response :success
+          assert_not json_response.empty?
+          assert json_response['results'].is_a?(Array)
+        end
+
+        context 'with taxonomy given' do
+          test 'index should return puppetclasses only in Organization' do
+            get :index, params: { organization_id: default_organization.id }
+            assert_include json_response['results'].map { |_, v| v[0]['id'] }, puppetclass.id
+            assert_response :success
+          end
+
+          test 'index should return puppetclasses only in Organization' do
+            get :index, params: { location_id: default_location.id }
+            assert_include json_response['results'].map { |_, v| v[0]['id'] }, puppetclass.id
+            assert_response :success
+          end
+
+          test 'index should return puppetclasses only in Organization' do
+            get :index, params: { location_id: default_location.id, organization_id: default_organization.id }
+            assert_include json_response['results'].map { |_, v| v[0]['id'] }, puppetclass.id
+            assert_response :success
+          end
+        end
+
+        test 'should create puppetclass' do
+          assert_difference(-> { ForemanPuppet::Puppetclass.count }) do
+            post :create, params: { puppetclass: valid_attrs }
+          end
+          assert_response :created
+          assert Puppetclass.exists?(name: valid_attrs[:name])
+        end
+
+        test 'should update puppetclass' do
+          put :update, params: { id: puppetclass.to_param, puppetclass: valid_attrs }
+          assert_response :success
+          assert_equal valid_attrs[:name], puppetclass.reload.name
+        end
+
+        test 'should destroy puppetclasss' do
+          assert_difference(-> { ForemanPuppet::Puppetclass.count }, -1) do
+            delete :destroy, params: { id: puppetclass.to_param }
+          end
+          assert_response :success
+        end
+
+        test 'should get puppetclasses for given host only' do
+          host1 = FactoryBot.create(:host, :with_puppet_enc, :with_puppetclass)
+          FactoryBot.create(:host, :with_puppet_enc, :with_puppetclass)
+          get :index, params: { host_id: host1.to_param }
+          assert_response :success
+          assert_equal host1.puppet.puppetclasses.map(&:name).sort, json_response['results'].keys.sort
+        end
+
+        test 'should not get puppetclasses for nonexistent host' do
+          get :index, params: { 'search' => 'host = imaginaryhost.nodomain.what' }
+          assert_response :success
+          assert_empty json_response['results']
+        end
+
+        test 'should get puppetclasses for hostgroup' do
+          hostgroup = FactoryBot.create(:hostgroup, :with_puppet_enc, :with_puppetclass)
+          get :index, params: { hostgroup_id: hostgroup.to_param }
+          assert_response :success
+          assert_not json_response['results'].empty?
+          assert_equal hostgroup.puppet.puppetclasses.map(&:name).sort, json_response['results'].keys.sort
+        end
+
+        test 'should get puppetclasses for environment' do
+          environment = FactoryBot.create(:environment, :with_puppetclass)
+          get :index, params: { environment_id: environment.to_param }
+          assert_response :success
+          assert_not json_response['results'].empty?
+          assert_equal environment.puppetclasses.map(&:name).sort, json_response['results'].keys.sort
+        end
+
+        test 'should show error if optional nested environment does not exist' do
+          get :index, params: { environment_id: 'nonexistent' }
+          assert_response 404
+          assert_equal "Environment not found by id 'nonexistent'", json_response['message']
+        end
+
+        test 'should show puppetclass for host' do
+          host = FactoryBot.create(:host, :with_puppet_enc, :with_puppetclass)
+          get :show, params: { host_id: host.to_param, id: host.puppet.puppetclasses.first.id }
+          assert_response :success
+          assert_not_empty json_response
+        end
+
+        test 'should show puppetclass for hostgroup' do
+          hostgroup = FactoryBot.create(:hostgroup, :with_puppet_enc, :with_puppetclass)
+          get :show, params: { hostgroup_id: hostgroup.to_param, id: hostgroup.puppet.puppetclasses.first.id }
+          assert_response :success
+          assert_not_empty json_response
+        end
+
+        test 'should show puppetclass for environment' do
+          environment = FactoryBot.create(:environment, :with_puppetclass)
+          get :show, params: { environment_id: environment, id: environment.puppetclasses.first.id }
+          assert_response :success
+          assert_not_empty json_response
+        end
+
+        test 'should not remove puppetclass params' do
+          FactoryBot.create(:puppetclass_lookup_key, puppetclass: puppetclass)
+          assert_equal 1, puppetclass.class_params.length
+          put :update, params: { id: puppetclass.id, smart_class_parameter_ids: [] }
+          puppetclass.reload
+          assert_equal 1, puppetclass.class_params.length
+        end
+      end
+    end
+  end
+end