foreman_puppet 0.0.1

data/test/models/foreman_puppet/hostgroup_test.rb

@@ -0,0 +1,14 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  class HostgroupTest < ActiveSupport::TestCase
+    let(:hostgroup) { FactoryBot.create(:hostgroup, :with_puppet_enc, :with_config_group) }
+
+    test 'search hostgroups by config group' do
+      config_group = hostgroup.puppet.config_groups.first
+      hostgroups = ::Hostgroup.search_for("config_group = #{config_group.name}")
+      assert_equal 1, hostgroups.count
+      assert_equal hostgroups.pluck(:id).sort, hostgroups.map(&:id).sort
+    end
+  end
+end

data/test/models/foreman_puppet/lookup_value_test.rb

@@ -0,0 +1,69 @@
+require_relative '../../test_puppet_helper'
+
+module ForemanPuppet
+  class LookupValueTest < ActiveSupport::TestCase
+    let(:boolean_lookup_key) { FactoryBot.create(:puppetclass_lookup_key, :boolean, path: "hostgroup\nfqdn\nhostgroup,domain") }
+
+    test 'boolean lookup value should not allow for nil value' do
+      lookup_value = LookupValue.new(value: nil, match: 'hostgroup=Common', lookup_key_id: boolean_lookup_key.id)
+      assert_not lookup_value.valid?
+    end
+
+    test 'boolean lookup value should allow nil value if omit is true' do
+      lookup_value = LookupValue.new(value: nil, match: 'hostgroup=Common', lookup_key_id: boolean_lookup_key.id, omit: true)
+      assert_valid lookup_value
+    end
+
+    test "shouldn't save with empty boolean matcher for smart class parameter" do
+      lookup_key = FactoryBot.create(:puppetclass_lookup_key, :boolean, override: true, description: 'description')
+      lookup_value = FactoryBot.build_stubbed(:lookup_value, lookup_key: lookup_key, match: 'os=fake', value: '')
+      assert_not lookup_value.valid?
+    end
+
+    test 'impact parameter delete attribute' do
+      hostgroup_name = RFauxFactory.gen_alpha
+      puppetclass = FactoryBot.create(:puppetclass)
+      environment = FactoryBot.create(:environment)
+      hostgroup = FactoryBot.create(:hostgroup, :with_puppet_enc, name: hostgroup_name, environment: environment, puppetclasses: [puppetclass])
+      match = "hostgroup=#{hostgroup_name}"
+      match_value = RFauxFactory.gen_alpha
+      lookup_key = FactoryBot.create(:puppetclass_lookup_key, default_value: 'list', puppetclass: FactoryBot.create(:puppetclass))
+      FactoryBot.create(:lookup_value, lookup_key: lookup_key, value: match_value, match: match)
+      lookup_key = LookupKey.unscoped.find_by(id: lookup_key.id)
+      assert_equal lookup_key.override_values.first.match, match
+      assert_equal lookup_key.override_values.first.value, match_value
+      hostgroup.destroy
+      lookup_key.reload
+      assert_equal(0, lookup_key.override_values.length)
+      FactoryBot.create(:hostgroup, :with_puppet_enc, name: hostgroup_name, environment: environment, puppetclasses: [puppetclass])
+      assert_equal(0, lookup_key.override_values.count)
+    end
+
+    context 'when key is a boolean and default_value is a string' do
+      let(:puppet_boolean_string) do
+        FactoryBot.create(:puppetclass_lookup_key, override: true, key_type: 'boolean',
+                                                   default_value: 'whatever', omit: true)
+      end
+      let(:lookup_value) { LookupValue.new(value: 'abc', match: 'hostgroup=Common', lookup_key_id: puppet_boolean_string.id, omit: true) }
+
+      test 'value is not validated if omit is true' do
+        assert_valid lookup_value
+        lookup_value.omit = false
+        refute_valid lookup_value
+      end
+    end
+
+    context 'when key type is puppetclass lookup and value is empty' do
+      let(:puppet_string_empty) do
+        FactoryBot.create(:puppetclass_lookup_key, :with_override, :with_omit, path: "hostgroup\ncomment", key_type: 'string')
+      end
+      let(:lookup_value) { LookupValue.new(value: '', match: 'hostgroup=Common', lookup_key_id: puppet_string_empty.id, omit: true) }
+
+      test 'value is validated if omit is true' do
+        assert_valid lookup_value
+        lookup_value.omit = false
+        refute_valid lookup_value
+      end
+    end
+  end
+end

data/test/models/foreman_puppet/provisioning_template_test.rb

@@ -0,0 +1,124 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  class ProvisioningTemplateTest < ActiveSupport::TestCase
+    let(:environment) { FactoryBot.create(:environment) }
+
+    test 'should save assoications if not snippet' do
+      tmplt = ProvisioningTemplate.new
+      tmplt.name = 'Some finish script'
+      tmplt.template = 'echo $HOME'
+      tmplt.template_kind = template_kinds(:finish)
+      tmplt.snippet = false # this is the default, but it helps show the case
+      tmplt.hostgroups << hostgroups(:common)
+      tmplt.environments << environment
+      as_admin do
+        assert tmplt.save
+      end
+      assert_equal template_kinds(:finish), tmplt.template_kind
+      assert_equal [hostgroups(:common)], tmplt.hostgroups
+      assert_equal [environment], tmplt.environments
+    end
+
+    test 'should not save assoications if snippet' do
+      tmplt          = ProvisioningTemplate.new
+      tmplt.name     = 'Default Kickstart'
+      tmplt.template = 'Some kickstart goes here'
+      tmplt.snippet  = true
+      tmplt.template_kind = template_kinds(:ipxe)
+      tmplt.hostgroups << hostgroups(:common)
+      tmplt.environments << environment
+      as_admin do
+        assert tmplt.save
+      end
+      assert_nil tmplt.template_kind
+      assert_equal [], tmplt.hostgroups
+      assert_equal [], tmplt.environments
+      assert_equal [], tmplt.template_combinations
+    end
+
+    describe 'Association cascading' do
+      setup do
+        @arch = FactoryBot.create(:architecture)
+        medium = FactoryBot.create(:medium, name: 'combo_medium', path: 'http://www.example.com/m')
+        @os1 = FactoryBot.create(:rhel7_5, media: [medium], architectures: [@arch])
+        @hg1 = FactoryBot.create(:hostgroup, name: 'hg1', operatingsystem: @os1, architecture: @arch, medium: @os1.media.first)
+        @hg2 = FactoryBot.create(:hostgroup, name: 'hg2', operatingsystem: @os1, architecture: @arch)
+        @hg3 = FactoryBot.create(:hostgroup, name: 'hg3', operatingsystem: @os1, architecture: @arch)
+        @ev1 = FactoryBot.create(:environment, name: 'env1')
+        @ev2 = FactoryBot.create(:environment, name: 'env2')
+        @ev3 = FactoryBot.create(:environment, name: 'env3')
+
+        @tk = TemplateKind.find_by(name: 'provision')
+
+        # Most specific template association
+        @ct1 = FactoryBot.create(:provisioning_template, name: 'ct1', template_kind: @tk, operatingsystems: [@os1])
+        @ct1.template_combinations.create(hostgroup: @hg1, environment: @ev1)
+
+        # HG only
+        # We add an association on HG2/EV2 to ensure that we're not just blindly
+        # selecting all template_combinations where environment_id => nil
+        @ct2 = FactoryBot.create(:provisioning_template, name: 'ct2', template_kind: @tk, operatingsystems: [@os1])
+        @ct2.template_combinations.create(hostgroup: @hg1, environment: nil)
+        @ct2.template_combinations.create(hostgroup: @hg2, environment: @ev2)
+
+        # Env only
+        # We add an association on HG2/EV2 to ensure that we're not just blindly
+        # selecting all template_combinations where hostgroup_id => nil
+        @ct3 = FactoryBot.create(:provisioning_template, name: 'ct3', template_kind: @tk, operatingsystems: [@os1])
+        @ct3.template_combinations.create(hostgroup: nil, environment: @ev1)
+        @ct3.template_combinations.create(hostgroup: @hg2, environment: @ev2)
+
+        # Default template for the OS
+        @ctd = FactoryBot.create(:provisioning_template, name: 'ctd', template_kind: @tk, operatingsystems: [@os1])
+        @ctd.os_default_templates.create(operatingsystem: @os1, template_kind_id: @ctd.template_kind_id)
+      end
+
+      test 'find_template finds a matching template with hg and env' do
+        assert_equal @ct1.name,
+          ProvisioningTemplate.find_template({ kind: @tk.name,
+                                               operatingsystem_id: @os1.id,
+                                               hostgroup_id: @hg1.id,
+                                               environment_id: @ev1.id }).name
+      end
+
+      test 'find_template finds a matching template with hg only' do
+        assert_equal @ct2.name,
+          ProvisioningTemplate.find_template({ kind: @tk.name,
+                                               operatingsystem_id: @os1.id,
+                                               hostgroup_id: @hg1.id }).name
+      end
+
+      test 'find_template finds a matching template with hg and mismatched env' do
+        assert_equal @ct2.name,
+          ProvisioningTemplate.find_template({ kind: @tk.name,
+                                               operatingsystem_id: @os1.id,
+                                               hostgroup_id: @hg1.id,
+                                               environment_id: @ev3.id }).name
+      end
+
+      test 'find_template finds a matching template with env only' do
+        assert_equal @ct3.name,
+          ProvisioningTemplate.find_template({ kind: @tk.name,
+                                               operatingsystem_id: @os1.id,
+                                               environment_id: @ev1.id }).name
+      end
+
+      test 'find_template finds a matching template with env and mismatched hg' do
+        assert_equal @ct3.name,
+          ProvisioningTemplate.find_template({ kind: @tk.name,
+                                               operatingsystem_id: @os1.id,
+                                               hostgroup_id: @hg3.id,
+                                               environment_id: @ev1.id }).name
+      end
+
+      test 'find_template finds the default template when hg and env do not match' do
+        assert_equal @ctd.name,
+          ProvisioningTemplate.find_template({ kind: @tk.name,
+                                               operatingsystem_id: @os1.id,
+                                               hostgroup_id: @hg3.id,
+                                               environment_id: @ev3.id }).name
+      end
+    end
+  end
+end

data/test/models/foreman_puppet/puppetclass_lookup_key_test.rb

@@ -0,0 +1,81 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  class PuppetclassLookupKeyTest < ActiveSupport::TestCase
+    test 'should not update default value unless override is true' do
+      lookup_key = FactoryBot.create(:puppetclass_lookup_key, override: false, default_value: 'test123')
+      assert_not lookup_key.override
+      lookup_key.default_value = '33333'
+      assert_not lookup_key.valid?
+    end
+
+    test 'default_value is only validated if omit is false' do
+      lookup_key = FactoryBot.create(:puppetclass_lookup_key, :boolean, override: true, omit: true)
+      lookup_key.default_value = 'whatever'
+      assert lookup_key.valid?
+      lookup_key.omit = false
+      assert_not lookup_key.valid?
+    end
+
+    test 'should update description when override is false' do
+      lookup_key = FactoryBot.create(:puppetclass_lookup_key, override: false, description: 'description')
+      assert_not lookup_key.override
+      lookup_key.description = 'new_description'
+      assert lookup_key.valid?
+    end
+
+    test 'should save without changes when override is false' do
+      lookup_key = FactoryBot.create(:puppetclass_lookup_key, override: false,
+                                                              default_value: 'test123',
+                                                              description: 'description')
+      assert_not lookup_key.override
+      assert lookup_key.valid?
+    end
+
+    test 'should allow to uncheck override' do
+      lookup_key = FactoryBot.create(:puppetclass_lookup_key, override: true)
+
+      lookup_key.override = false
+      assert lookup_key.valid?
+    end
+
+    test 'should be smart class parameter #puppet? => true' do
+      assert_not_deprecated do
+        assert FactoryBot.create(:puppetclass_lookup_key).puppet?
+      end
+    end
+
+    context 'delete params with class' do
+      let(:environment) { FactoryBot.create(:environment) }
+      let(:puppetclass) { FactoryBot.create(:puppetclass, environments: [environment]) }
+      let(:lookup_key) { FactoryBot.create(:puppetclass_lookup_key, puppetclass: puppetclass, override: true) }
+
+      test 'deleting puppetclass should delete smart class parameters' do
+        env2 = FactoryBot.create(:environment)
+        FactoryBot.create(:environment_class, puppetclass: puppetclass, environment: env2, puppetclass_lookup_key: lookup_key)
+
+        puppetclass.destroy
+        assert_not ForemanPuppet::PuppetclassLookupKey.where(key: lookup_key.key).present?
+      end
+
+      test 'deleting only environment a smart class parameters is in should delete the parameter' do
+        lookup_key
+        environment.destroy
+        assert_not ForemanPuppet::PuppetclassLookupKey.where(key: lookup_key.key).present?
+      end
+
+      test 'deleting only one environment a smart class parameters is in should not delete the parameter' do
+        env2 = FactoryBot.create(:environment)
+        FactoryBot.create(:environment_class, puppetclass: puppetclass, environment: env2, puppetclass_lookup_key: lookup_key)
+
+        environment.destroy
+        assert ForemanPuppet::PuppetclassLookupKey.where(key: lookup_key.key).present?
+      end
+    end
+
+    test 'should have auditable_type as PuppetclassLookupKey and not LookupKey' do
+      ForemanPuppet::PuppetclassLookupKey.create(key: 'test_audit_parameter', default_value: 'test123')
+      assert_equal 'ForemanPuppet::PuppetclassLookupKey', Audit.unscoped.last.auditable_type
+    end
+  end
+end

data/test/models/foreman_puppet/puppetclass_test.rb

@@ -0,0 +1,144 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  class PuppetclassTest < ActiveSupport::TestCase
+    setup do
+      User.current = users(:admin)
+    end
+
+    should validate_presence_of(:name)
+    should validate_uniqueness_of(:name)
+
+    test 'name strips leading and trailing white spaces' do
+      puppet_class = Puppetclass.new name: '   testclass   '
+      assert puppet_class.save
+      assert_not puppet_class.name.ends_with?(' ')
+      assert_not puppet_class.name.starts_with?(' ')
+    end
+
+    test 'looking for a nonexistent host returns no puppetclasses' do
+      assert_equal [], Puppetclass.search_for('host = imaginaryhost.nodomain.what')
+    end
+
+    test 'Puppetclass singularize from custom inflection' do
+      assert_equal 'Puppetclass', 'Puppetclass'.singularize
+      assert_equal 'Puppetclass', 'Puppetclasses'.singularize
+      assert_equal 'puppetclass', 'puppetclass'.singularize
+      assert_equal 'puppetclass', 'puppetclasses'.singularize
+    end
+
+    test 'Puppetclass classify from custom inflection' do
+      assert_equal 'Puppetclass', 'Puppetclass'.classify
+      assert_equal 'Puppetclass', 'Puppetclasses'.classify
+      assert_equal 'Puppetclass', 'puppetclass'.classify
+      assert_equal 'Puppetclass', 'puppetclasses'.classify
+    end
+
+    context 'all_hostgroups should show hostgroups and their descendants' do
+      setup do
+        @class = FactoryBot.create(:puppetclass)
+        @hg1 = FactoryBot.create(:hostgroup, :with_puppet_enc)
+        @hg2 = FactoryBot.create(:hostgroup, :with_puppet_enc, parent_id: @hg1.id)
+        @hg3 = FactoryBot.create(:hostgroup, :with_puppet_enc, parent_id: @hg2.id)
+        @config_group = FactoryBot.create(:config_group)
+        @hg1.puppet.config_groups << @config_group
+      end
+
+      it 'when added directly' do
+        assert_difference('@class.all_hostgroups.count', 3) do
+          @class.hostgroup_puppet_facets << @hg1.puppet
+        end
+      end
+
+      it 'when added directly and called without descendants' do
+        assert_difference(-> { @class.all_hostgroups(with_descendants: false).count }, 1) do
+          @class.hostgroup_puppet_facets << @hg1.puppet
+        end
+      end
+
+      it 'when added via config group' do
+        assert_difference('@class.all_hostgroups.count', 3) do
+          @class.config_groups << @config_group
+        end
+      end
+
+      it 'when added directly and called without descendants' do
+        assert_difference(-> { @class.all_hostgroups(with_descendants: false).count }, 1) do
+          @class.config_groups << @config_group
+        end
+      end
+    end
+
+    context 'host counting' do
+      setup do
+        @env = FactoryBot.create(:environment)
+        @class = FactoryBot.create(:puppetclass)
+        @parent_hg = FactoryBot.create(:hostgroup, :with_puppet_enc)
+        @hostgroup = FactoryBot.create(:hostgroup, :with_puppet_enc, parent: @parent_hg)
+        @config_group = FactoryBot.create(:config_group, puppetclasses: [@class])
+        @host = FactoryBot.create(:host, :with_puppet_enc, environment: @env)
+      end
+
+      test 'correctly counts direct hosts' do
+        @host.puppet.puppetclasses << @class
+        assert_equal 1, @class.hosts_count
+      end
+
+      test 'correctly counts hosts via config group' do
+        @host.puppet.config_groups << @config_group
+        assert_equal 1, @class.hosts_count
+      end
+
+      test 'correctly counts hosts via hostgroup' do
+        @hostgroup.puppet.puppetclasses << @class
+        @host.update(hostgroup_id: @hostgroup.id)
+        assert_equal 1, @class.hosts_count
+      end
+
+      test 'correctly counts hosts via parent hostgroup' do
+        @host.update(hostgroup_id: @hostgroup.id)
+        @parent_hg.puppet.puppetclasses << @class
+        assert_equal 1, @class.hosts_count
+      end
+
+      test 'correctly counts hosts via hostgroup config group' do
+        @host.update(hostgroup_id: @hostgroup.id)
+        @hostgroup.puppet.config_groups << @config_group
+        assert_equal 1, @class.hosts_count
+      end
+
+      test 'correctly counts hosts via parent hostgroup config group' do
+        @host.update(hostgroup_id: @hostgroup.id)
+        @parent_hg.puppet.config_groups << @config_group
+        assert_equal 1, @class.hosts_count
+      end
+
+      test 'only count host once even if it has multiple connections to puppetclass' do
+        @host.puppet.puppetclasses << @class
+        @host.puppet.config_groups << @config_group
+        @hostgroup.puppet.puppetclasses << @class
+        @hostgroup.puppet.config_groups << @config_group
+        @parent_hg.puppet.puppetclasses << @class
+        @parent_hg.puppet.config_groups << @config_group
+        @host.update(hostgroup_id: @hostgroup.id)
+        assert_equal 1, @class.hosts_count
+      end
+    end
+
+    context 'search in puppetclasses' do
+      setup do
+        @class = FactoryBot.create(:puppetclass)
+        @hostgroup = FactoryBot.create(:hostgroup, :with_puppet_enc, puppetclasses: [@class])
+        @config_group = FactoryBot.create(:config_group, puppetclasses: [@class])
+      end
+
+      test 'search for puppetclass by hostgroup' do
+        assert_includes(Puppetclass.search_for("hostgroup = #{@hostgroup.to_label}"), @class)
+      end
+
+      test 'search for puppetclass by config_group' do
+        assert_includes(Puppetclass.search_for("config_group = #{@config_group.to_label}"), @class)
+      end
+    end
+  end
+end

data/test/models/foreman_puppet/smart_proxy_test.rb

@@ -0,0 +1,28 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  class SmartProxyTest < ActiveSupport::TestCase
+    let(:proxy) { FactoryBot.create(:puppet_smart_proxy) }
+
+    test 'should return environment stats' do
+      ProxyAPI::Puppet.any_instance.expects(:environments).returns(%w[env1 env2])
+      ProxyAPI::Puppet.any_instance.expects(:class_count).with('env1').returns(1)
+      ProxyAPI::Puppet.any_instance.expects(:class_count).with('env2').returns(2)
+      assert_equal({ 'env1' => 1, 'env2' => 2 }, proxy.statuses[:puppet].environment_stats)
+    end
+
+    describe 'older v1 api' do
+      before do
+        ProxyAPI::V2::Features.any_instance.stubs(:features).raises(NotImplementedError.new('not supported'))
+      end
+
+      test 'can count connected hosts' do
+        FactoryBot.create(:host, :with_puppet_enc, :with_environment, puppet_proxy: proxy)
+
+        as_admin do
+          assert_equal 1, proxy.hosts_count
+        end
+      end
+    end
+  end
+end