foreman_puppet 0.0.1

data/test/controllers/foreman_puppet/puppet_smart_proxies_controller_test.rb

@@ -0,0 +1,29 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  class PuppetSmartProxiesControllerTest < ActionController::TestCase
+    setup do
+      @routes = ForemanPuppet::Engine.routes
+      stub_smart_proxy_v2_features
+    end
+
+    test '#environments' do
+      proxy = smart_proxies(:puppetmaster)
+      fake_data = { 'env1' => 1, 'special_environment' => 4 }
+      ForemanPuppet::ProxyStatus::Puppet.any_instance.expects(:environment_stats).returns(fake_data)
+      get :environments, params: { id: proxy.id }, session: set_session_user, xhr: true
+      assert_response :success
+      assert_template 'foreman_puppet/puppet_smart_proxies/_environments'
+      assert_includes @response.body, 'special_environment'
+      assert_includes @response.body, '5' # the total is correct
+    end
+
+    test '#dashboard' do
+      proxy = smart_proxies(:puppetmaster)
+      get :dashboard, params: { id: proxy.id }, session: set_session_user, xhr: true
+      assert_response :success
+      assert_template 'foreman_puppet/puppet_smart_proxies/_dashboard'
+      assert_includes @response.body, 'Latest Events'
+    end
+  end
+end

data/test/controllers/foreman_puppet/puppetclass_lookup_keys_controller_test.rb

@@ -0,0 +1,59 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  class PuppetclassLookupKeysControllerTest < ActionController::TestCase
+    setup do
+      @routes = ForemanPuppet::Engine.routes
+      @factory_options = [{ puppetclass: puppetclasses(:one), override: true, default_value: 'test' }]
+    end
+
+    let(:lookup_key) { FactoryBot.create(:puppetclass_lookup_key, puppetclass: puppetclasses(:one), override: true) }
+
+    basic_pagination_rendered_test
+    basic_pagination_per_page_test
+
+    test 'should get index' do
+      lookup_key # we dont want to render welcome
+      get :index, session: set_session_user
+      assert_response :success
+      assert_not_nil assigns(:lookup_keys)
+    end
+
+    test 'should get edit' do
+      get :edit, params: { id: lookup_key.to_param }, session: set_session_user
+      assert_response :success
+    end
+
+    test 'should update lookup_keys' do
+      put :update, params: { id: lookup_key.to_param, puppetclass_lookup_key: { description: 'test that' } }, session: set_session_user
+      assert_equal 'test that', lookup_key.reload.description
+      assert_redirected_to puppetclass_lookup_keys_path
+    end
+
+    test 'should destroy lookup_keys' do
+      lookup_key
+      assert_difference(-> { ForemanPuppet::PuppetclassLookupKey.count }, -1) do
+        delete :destroy, params: { id: lookup_key.to_param }, session: set_session_user
+      end
+      assert_redirected_to puppetclass_lookup_keys_path
+    end
+
+    test 'user with viewer rights should fail to edit an external variable' do
+      setup_user
+      get :edit, params: { id: lookup_key.id }, session: set_session_user(:one)
+      assert_equal(403, response.status)
+    end
+
+    test 'user with viewer rights should succeed in viewing external variables' do
+      setup_user
+      get :index, session: set_session_user(:one)
+      assert_response :success
+    end
+
+    private
+
+    def setup_user
+      users(:one).roles = [Role.default, Role.find_by(name: 'Viewer')]
+    end
+  end
+end

data/test/controllers/foreman_puppet/puppetclasses_controller_test.rb

@@ -0,0 +1,235 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  class PuppetclassesControllerTest < ActionController::TestCase
+    include PuppetclassLookupKeysHelper
+
+    setup do
+      @routes = ForemanPuppet::Engine.routes
+    end
+
+    let(:org) { users(:one).organizations.first }
+    let(:loc) { users(:one).locations.first }
+    let(:environment) { FactoryBot.create(:environment, organizations: [org], locations: [loc]) }
+    let(:puppetclass) { FactoryBot.create(:puppetclass, :with_parameters, environments: [environment]) }
+
+    basic_pagination_rendered_test
+    basic_pagination_per_page_test
+
+    def test_index
+      get :index, session: set_session_user
+      assert_template 'index'
+    end
+
+    def test_edit
+      get :edit, params: { id: puppetclass.to_param }, session: set_session_user
+      assert_template 'edit'
+    end
+
+    def test_update_invalid
+      put :update, params: { id: puppetclass.to_param, puppetclass: { name: nil } }, session: set_session_user
+      assert_template 'edit'
+    end
+
+    def test_update_valid
+      put :update, params: { id: puppetclass, puppetclass: { name: 'foo' } }, session: set_session_user
+      assert_equal 'foo', puppetclass.reload.name
+      assert_redirected_to puppetclasses_url
+    end
+
+    def test_destroy
+      delete :destroy, params: { id: puppetclass.to_param }, session: set_session_user
+      assert_redirected_to puppetclasses_url
+      assert_not Puppetclass.exists?(puppetclass.id)
+    end
+
+    test 'user with viewer rights should fail to edit a puppetclass' do
+      setup_user
+      get :edit, params: { id: puppetclass.to_param }, session: set_session_user(:one)
+      assert_equal(403, @response.status)
+    end
+
+    test 'user with viewer rights should succeed in viewing puppetclasses' do
+      setup_user
+      get :index, session: set_session_user
+      assert_response :success
+    end
+
+    describe '#parameters' do
+      setup { puppetclass.class_params.each { |plk| plk.update(override: true) } }
+
+      test 'new db rows are not added to HostClass when POST to parameters' do
+        host = FactoryBot.create(:host, :with_puppet_enc, :with_puppetclass)
+        host_puppetclass_ids = host.host_classes.pluck(:puppetclass_id)
+        params = {  id: puppetclass.id,
+                    host_id: host.id,
+                    host: { puppetclass_ids: (host_puppetclass_ids + [puppetclass.id]) } }
+        assert_difference('HostClass.count', 0) do
+          post :parameters, params: params, session: set_session_user
+        end
+      end
+
+      test 'new db rows are not added to HostgroupClass when POST to parameters' do
+        skip 'dont know how to achieve for now' unless ForemanPuppet.extracted_from_core?
+        hostgroup = FactoryBot.create(:hostgroup, :with_puppet_enc, :with_puppetclass)
+        hostgroup_puppetclass_ids = hostgroup.puppet.hostgroup_classes.pluck(:puppetclass_id)
+        params = {  id: puppetclass.id,
+                    host_id: hostgroup.id,
+                    hostgroup: { puppetclass_ids: (hostgroup_puppetclass_ids + [puppetclass.id]) } }
+        assert_difference('ForemanPuppet::HostgroupClass.count', 0) do
+          post :parameters, params: params, session: set_session_user
+        end
+      end
+
+      # NOTES: for tests below testing ajax POST to method parameters
+      # puppetclass(:two) has an overridable lookup key custom_class_param.
+      # custom_class_param is a smart_class_param for production environment only AND is marked as :override => TRUE
+      test 'puppetclass lookup keys are added to partial _class_parameters on EXISTING host form through ajax POST to parameters' do
+        host = FactoryBot.create(:host, :with_puppet_enc, environment: environment)
+        existing_host_attributes = host_attributes(host)
+        post :parameters, params: { id: puppetclass.id, host_id: host.id,
+                                    host: existing_host_attributes }, session: set_session_user
+        assert_response :success
+        lookup_keys_added = overridable_puppet_lookup_keys(puppetclass, host)
+        assert_equal 1, lookup_keys_added.count
+        assert_includes lookup_keys_added.map(&:key), puppetclass.class_params.first.key
+      end
+
+      test 'puppetclass smart class parameters are NOT added if environment does not match' do
+        # below is the same test as above, except environment is changed from production to global_puppetmaster, so custom_class_param is NOT added
+        host = FactoryBot.create(:host, :with_puppet_enc, environment: environment)
+        existing_host_attributes = host_attributes(host)
+        existing_host_attributes['puppet_attributes'] = { 'environment_id' => FactoryBot.create(:environment).id }
+        post :parameters, params: { id: puppetclass.id, host_id: host.id,
+                                    host: existing_host_attributes }, session: set_session_user
+        assert_response :success
+        as_admin do
+          lookup_keys_added = overridable_puppet_lookup_keys(puppetclass, assigns(:obj))
+          assert_equal 0, lookup_keys_added.count
+          assert_not lookup_keys_added.map(&:key).include?(puppetclass.class_params.first.key)
+        end
+      end
+
+      test 'puppetclass lookup keys are added to partial _class_parameters on EXISTING hostgroup form through ajax POST to parameters' do
+        hostgroup = FactoryBot.create(:hostgroup, :with_puppet_enc, environment: environment)
+        existing_hostgroup_attributes = hostgroup_attributes(hostgroup)
+        # host_id is posted instead of hostgroup_id per host_edit.js#load_puppet_class_parameters
+        post :parameters, params: { id: puppetclass.id, host_id: hostgroup.id,
+                                    hostgroup: existing_hostgroup_attributes }, session: set_session_user
+        assert_response :success
+        as_admin do
+          lookup_keys_added = overridable_puppet_lookup_keys(puppetclass, hostgroup)
+          assert_equal 1, lookup_keys_added.count
+          assert_includes lookup_keys_added.map(&:key), puppetclass.class_params.first.key
+        end
+      end
+
+      test 'puppetclass lookup keys are added to partial _class_parameters on NEW host form through ajax POST to parameters' do
+        host = Host::Managed.new(name: 'new_host', puppet_attributes: { environment_id: environment.id })
+        new_host_attributes = host_attributes(host)
+        post :parameters, params: { id: puppetclass.id, host_id: 'undefined',
+                                    host: new_host_attributes }, session: set_session_user
+        assert_response :success
+        as_admin do
+          lookup_keys_added = overridable_puppet_lookup_keys(puppetclass, host)
+          assert_equal 1, lookup_keys_added.count
+          assert_includes lookup_keys_added.map(&:key), puppetclass.class_params.first.key
+        end
+      end
+
+      test 'puppetclass lookup keys are added to partial _class_parameters on NEW hostgroup form through ajax POST to parameters' do
+        hostgroup = Hostgroup.new(name: 'new_hostgroup', puppet_attributes: { environment_id: environment.id })
+        new_hostgroup_attributes = hostgroup_attributes(hostgroup)
+        # host_id is posted instead of hostgroup_id per host_edit.js#load_puppet_class_parameters
+        post :parameters, params: { id: puppetclass.id, host_id: 'undefined',
+                                    hostgroup: new_hostgroup_attributes }, session: set_session_user
+        assert_response :success
+        as_admin do
+          lookup_keys_added = overridable_puppet_lookup_keys(puppetclass, hostgroup)
+          assert_equal 1, lookup_keys_added.count
+          assert_includes lookup_keys_added.map(&:key), puppetclass.class_params.first.key
+        end
+      end
+    end
+
+    test 'sorting by environment name on the index screen should work' do
+      setup_user
+      puppetclass
+      get :index, params: { order: 'environment ASC' }, session: set_session_user
+      assert_includes assigns(:puppetclasses), puppetclass
+    end
+
+    test 'text filtering on the index screen should work' do
+      setup_user
+      get :index, params: { search: puppetclass.name }, session: set_session_user
+      assert_includes assigns(:puppetclasses), puppetclass
+    end
+
+    test 'predicate filtering on the index screen should work' do
+      setup_user
+      puppetclass
+      get :index, params: { search: "environment = #{environment.name}" }, session: set_session_user
+      assert_includes assigns(:puppetclasses), puppetclass
+    end
+
+    def test_override_enable
+      puppetclass.class_params.first.update(override: false)
+      assert_changes -> { puppetclass.class_params.first.reload.override }, from: false, to: true do
+        post :override, params: { id: puppetclass.to_param, enable: 'true' }, session: set_session_user
+      end
+      assert_match(/overridden all parameters/, flash[:success])
+      assert_redirected_to puppetclasses_url
+    end
+
+    def test_override_disable
+      puppetclass.class_params.first.update(override: true)
+      post :override, params: { id: puppetclass.to_param, enable: 'false' }, session: set_session_user
+      assert_not puppetclass.class_params.reload.first.override
+      assert_match(/reset all parameters/, flash[:success])
+      assert_redirected_to puppetclasses_url
+    end
+
+    def test_override_none
+      puppetclass = FactoryBot.create(:puppetclass)
+      post :override, params: { id: puppetclass.to_param }, session: set_session_user
+      assert_match(/No parameters to override/, flash[:error])
+      assert_redirected_to puppetclasses_url
+    end
+
+    test 'user with edit_puppetclasses permission should succeed in overriding all parameters' do
+      puppetclass.class_params.first.update(override: false)
+      setup_user 'edit', 'puppetclasses'
+      post :override, params: { id: puppetclass.to_param, enable: 'true' }, session: set_session_user(:one)
+      assert_match(/overridden all parameters/, flash[:success])
+      assert_redirected_to puppetclasses_url
+    end
+
+    test 'user without edit_puppetclasses permission should fail in overriding all parameters' do
+      puppetclass.class_params.first.update(override: false)
+      setup_user 'view', 'puppetclasses'
+      post :override, params: { id: puppetclass.to_param, enable: 'true' }, session: set_session_user(:one)
+      assert_match(/You are not authorized to perform this action/, response.body)
+    end
+
+    private
+
+    def host_attributes(host)
+      known_attrs = HostsController.host_params_filter.accessible_attributes(HostsController.parameter_filter_context)
+      host.attributes.except('id', 'created_at', 'updated_at').slice(*known_attrs)
+    end
+
+    def hostgroup_attributes(hostgroup)
+      known_attrs = HostgroupsController.hostgroup_params_filter.accessible_attributes(HostgroupsController.parameter_filter_context)
+      hostgroup.attributes.except('id', 'created_at', 'updated_at', 'hosts_count', 'ancestry').slice(*known_attrs)
+    end
+
+    def setup_user(operation = nil, type = '', search = nil, user = :one)
+      if operation.nil?
+        @request.session[:user] = users(:one).id
+        users(:one).roles       = [Role.default, Role.find_by(name: 'Viewer')]
+      else
+        super
+      end
+    end
+  end
+end

data/test/controllers/provisioning_templates_controller_test.rb

@@ -0,0 +1,70 @@
+require 'test_puppet_helper'
+
+class ProvisioningTemplatesControllerTest < ActionController::TestCase
+  let(:environment) { FactoryBot.create(:environment) }
+  let(:template_combination) { FactoryBot.create(:template_combination, environment: environment) }
+
+  context 'templates combinations' do
+    test 'can be added on template creation' do
+      template_combination = { environment_id: environment.id,
+                               hostgroup_id: hostgroups(:db).id }
+      provisioning_template = {
+        name: 'foo',
+        template: '#nocontent',
+        template_kind_id: TemplateKind.find_by(name: 'iPXE').id,
+        template_combinations_attributes: { '3923' => template_combination },
+      }
+      assert_difference('TemplateCombination.unscoped.count', 1) do
+        assert_difference('ProvisioningTemplate.unscoped.count', 1) do
+          post :create, params: {
+            provisioning_template: provisioning_template,
+          }, session: set_session_user
+        end
+      end
+    end
+
+    context 'for already existing templates' do
+      test 'can be edited' do
+        new_environment = FactoryBot.create(:environment)
+        template = template_combination.provisioning_template
+        assert_not_equal new_environment, template_combination.environment
+        put :update, params: {
+          id: template.to_param,
+          provisioning_template: {
+            template_combinations_attributes: {
+              '0' => {
+                id: template_combination.id,
+                environment_id: new_environment.id,
+                hostgroup_id: template_combination.hostgroup.id,
+              },
+            },
+          },
+        }, session: set_session_user
+        assert_response :found
+        as_admin do
+          template_combination.reload
+          assert_equal new_environment, template_combination.environment
+        end
+      end
+
+      test 'can be destroyed' do
+        # create prior the request
+        template_combination
+        assert_difference('TemplateCombination.count', -1) do
+          put :update, params: {
+            id: template_combination.provisioning_template.to_param,
+            provisioning_template: {
+              template_combinations_attributes: {
+                '0' => {
+                  id: template_combination.id,
+                  _destroy: 1,
+                },
+              },
+            },
+          }, session: set_session_user
+        end
+        assert_response :found
+      end
+    end
+  end
+end

data/test/factories/foreman_puppet_factories.rb

@@ -0,0 +1,134 @@
+FactoryBot.factories.instance_variable_get('@items').delete(:config_group) if FactoryBot.factories.registered?(:config_group)
+FactoryBot.factories.instance_variable_get('@items').delete(:environment) if FactoryBot.factories.registered?(:environment)
+FactoryBot.factories.instance_variable_get('@items').delete(:environment_class) if FactoryBot.factories.registered?(:environment_class)
+FactoryBot.factories.instance_variable_get('@items').delete(:puppetclass) if FactoryBot.factories.registered?(:puppetclass)
+FactoryBot.factories.instance_variable_get('@items').delete(:puppetclass_lookup_key) if FactoryBot.factories.registered?(:puppetclass_lookup_key)
+
+def factory_set_environment_taxonomies(puppet_facet, environment = puppet_facet.environment)
+  if puppet_facet.is_a? ForemanPuppet::HostgroupPuppetFacet
+    organizations = puppet_facet.hostgroup.organizations
+    locations = puppet_facet.hostgroup.locations
+  else
+    organizations = [puppet_facet.host.organization].compact
+    locations = [puppet_facet.host.location].compact
+  end
+  return if environment.nil? || (organizations.empty? && locations.empty?)
+  environment.organizations = (environment.organizations + organizations).uniq
+  environment.locations = (environment.locations + locations).uniq
+  environment.save unless environment.new_record?
+end
+
+FactoryBot.define do
+  factory :common_puppet_facet do
+    environment
+  end
+
+  factory :host_puppet_facet, parent: :common_puppet_facet, class: 'ForemanPuppet::HostPuppetFacet' do
+    host
+
+    trait :with_config_group do
+      config_groups { [FactoryBot.create(:config_group, :with_puppetclass, class_environments: [environment])] }
+    end
+
+    after(:build) do |facet|
+      factory_set_environment_taxonomies(facet)
+    end
+  end
+
+  factory :hostgroup_puppet_facet, parent: :common_puppet_facet, class: 'ForemanPuppet::HostgroupPuppetFacet' do
+    hostgroup
+
+    trait :with_config_group do
+      config_groups { [FactoryBot.create(:config_group, :with_puppetclass, class_environments: [environment])] }
+    end
+
+    after(:build) do |facet|
+      factory_set_environment_taxonomies(facet)
+    end
+  end
+
+  factory :config_group, class: 'ForemanPuppet::ConfigGroup' do
+    sequence(:name) { |n| "config_group#{n}" }
+    transient do
+      class_environments { [] }
+    end
+
+    trait :with_puppetclass do
+      puppetclasses { [FactoryBot.create(:puppetclass, environments: class_environments)] }
+    end
+  end
+
+  factory :environment, class: 'ForemanPuppet::Environment' do
+    sequence(:name) { |n| "environment#{n}" }
+    organizations { [Organization.first || create(:organization)] }
+    locations { [Location.first || create(:location)] }
+
+    transient do
+      puppetclasses { [] }
+    end
+
+    trait :with_puppetclass do
+      transient do
+        puppetclasses { [create(:puppetclass)] }
+      end
+    end
+
+    after(:create) do |environment, evaluator|
+      evaluator.puppetclasses.each do |pc|
+        create(:environment_class, environment: environment, puppetclass: pc)
+      end
+    end
+  end
+
+  factory :environment_class, class: 'ForemanPuppet::EnvironmentClass' do
+    environment
+    puppetclass
+  end
+
+  factory :puppetclass, class: 'ForemanPuppet::Puppetclass' do
+    sequence(:name) { |n| "class#{n}" }
+
+    transient do
+      environments { [] }
+      parameter_count { 0 }
+    end
+
+    trait :with_parameters do
+      transient do
+        environments { [create(:environment)] }
+        parameter_count { 1 }
+      end
+    end
+
+    after(:create) do |pc, evaluator|
+      if evaluator.parameter_count.positive?
+        evaluator.parameter_count.times do
+          evaluator.environments.each do |env|
+            FactoryBot.create :puppetclass_lookup_key, override: false, puppetclass: pc, environment: env
+          end
+        end
+      else
+        evaluator.environments.each do |env|
+          FactoryBot.create :environment_class, puppetclass: pc, environment: env unless env.nil?
+        end
+      end
+    end
+  end
+
+  factory :puppetclass_lookup_key, parent: :lookup_key, class: 'ForemanPuppet::PuppetclassLookupKey' do
+    override { true }
+
+    transient do
+      puppetclass { create(:puppetclass) }
+      environment { nil }
+    end
+
+    after(:create) do |lkey, evaluator|
+      environments = evaluator.puppetclass.environments.to_a + [evaluator.environment].compact
+      environments = [FactoryBot.create(:environment)] unless environments.any?
+      environments.each do |env|
+        FactoryBot.create :environment_class, puppetclass: evaluator.puppetclass, environment: env, puppetclass_lookup_key_id: lkey.id
+      end
+    end
+  end
+end