foreman_puppet 0.0.1

data/test/integration/foreman_puppet/hostgroup_js_test.rb

@@ -0,0 +1,100 @@
+require 'test_puppet_helper'
+require 'integration_test_helper'
+
+module ForemanPuppet
+  class HostgroupJSTest < IntegrationTestWithJavascript
+    let(:hostgroup) { FactoryBot.create(:hostgroup, :with_puppet_enc, :with_puppetclass) }
+    let(:environment) { FactoryBot.create(:environment) }
+
+    describe 'create new page' do
+      test 'create new page' do
+        environment
+        assert_new_button(hostgroups_path, 'Create Host Group', new_hostgroup_path)
+        fill_in 'hostgroup_name', with: 'staging'
+        select2 environment.name, from: 'hostgroup_puppet_attributes_environment_id'
+        assert_submit_button(hostgroups_path)
+        assert_equal environment.id,
+          Hostgroup.find_by(name: 'staging').environment_id,
+          'Hostgroup not created or environment not set'
+      end
+    end
+
+    describe 'edit page' do
+      setup do
+        @another_puppetclass = FactoryBot.create(:puppetclass)
+      end
+
+      describe 'changing the environment' do
+        setup do
+          environment
+          @hostgroup = FactoryBot.create(:hostgroup, :with_puppet_enc)
+          visit hostgroups_path
+          click_link @hostgroup.name
+        end
+
+        test 'preserves the puppetclasses' do
+          puppetclasses = @hostgroup.puppet.puppetclasses.all
+
+          select2 environment.name, from: 'hostgroup_puppet_attributes_environment_id'
+          assert_submit_button(hostgroups_path)
+
+          assert_equal puppetclasses, @hostgroup.puppet.puppetclasses.all
+        end
+      end
+
+      context 'has inherited Puppetclasses' do
+        test 'has the parent group inherited parameters visible' do
+          child_hostgroup = FactoryBot.create(:hostgroup, parent: hostgroup)
+
+          visit edit_hostgroup_path(child_hostgroup)
+          switch_form_tab('Puppet ENC')
+
+          header_element = page.find('#puppet_enc_tab .panel h3 a')
+          assert header_element.text =~ /#{hostgroup.name}$/
+          header_element.click
+
+          class_element = page.find('#inherited_ids > li')
+          assert_equal hostgroup.puppet.puppetclasses.first.name, class_element.text
+        end
+      end
+
+      test 'shows errors on invalid lookup values' do
+        lookup_key = FactoryBot.create(:puppetclass_lookup_key, :integer,
+          path: 'hostgroup', puppetclass: hostgroup.puppet.puppetclasses.first,
+          overrides: { hostgroup.lookup_value_matcher => 2 })
+
+        visit edit_hostgroup_path(hostgroup)
+        switch_form_tab('Puppet ENC')
+        assert page.has_no_selector?('#puppet_klasses_parameters .input-group.has-error')
+        fill_in "hostgroup_lookup_values_attributes_#{lookup_key.id}_value", with: 'invalid'
+        click_button('Submit')
+        assert page.has_selector?('#puppet_klasses_parameters td.has-error')
+      end
+
+      context 'puppet classes are not available in the environment' do
+        test 'it shows a warning and marks as unavailable' do
+          hostgroup.puppet.puppetclasses << @another_puppetclass
+          visit edit_hostgroup_path(hostgroup)
+
+          switch_form_tab('Puppet ENC')
+
+          assert page.has_selector?('#puppetclasses_unavailable_warning')
+          assert page.has_selector?('.selected_puppetclass.unavailable')
+        end
+      end
+    end
+
+    describe 'clone page' do
+      test 'clones lookup values' do
+        lookup_key = FactoryBot.create(:puppetclass_lookup_key, path: "hostgroup\ncomment",
+                                                                puppetclass: hostgroup.puppet.puppetclasses.first,
+                                                                overrides: { hostgroup.lookup_value_matcher => 'abc' })
+
+        visit clone_hostgroup_path(hostgroup)
+        switch_form_tab('Puppet ENC')
+        a = page.find("#hostgroup_lookup_values_attributes_#{lookup_key.id}_value")
+        assert_equal 'abc', a.value
+      end
+    end
+  end
+end

data/test/integration/foreman_puppet/puppetclass_js_test.rb

@@ -0,0 +1,37 @@
+require 'test_puppet_helper'
+require 'integration_test_helper'
+
+module ForemanPuppet
+  class PuppetclassJsTest < IntegrationTestWithJavascript
+    include ForemanPuppet::Engine.routes.url_helpers
+    # intermittent failures:
+    #   PuppetclassIntegrationTest.test_0001_edit page
+
+    let(:environment) { FactoryBot.create(:environment) }
+    let(:puppetclass) { FactoryBot.create(:puppetclass, environments: [environment]) }
+
+    test 'edit page' do
+      visit puppetclasses_path
+      click_link 'vim'
+      assert page.has_no_link? 'Common'
+      find(:xpath, "//a[@data-original-title='Select All']").click
+      assert_submit_button(puppetclasses_path)
+      assert page.has_link? 'vim'
+      assert page.has_link? 'Common'
+    end
+
+    test 'verify key label exists in case key is too long' do
+      smart_class_parameter_long = FactoryBot.create(:puppetclass_lookup_key, puppetclass: puppetclass, variable: 'a' * 50)
+      visit edit_puppetclass_path(puppetclass)
+      click_link 'Smart Class Parameter'
+      assert_equal smart_class_parameter_long.key, page.find("#pill_#{smart_class_parameter_long.id}-#{smart_class_parameter_long.key}")['data-original-title']
+    end
+
+    test 'verify key label is empty in case key is short' do
+      smart_class_parameter_short = FactoryBot.create(:puppetclass_lookup_key, puppetclass: puppetclass, variable: 'a' * 40)
+      visit edit_puppetclass_path(puppetclass)
+      click_link 'Smart Class Parameter'
+      assert_empty page.find("#pill_#{smart_class_parameter_short.id}-#{smart_class_parameter_short.key}")['data-original-title']
+    end
+  end
+end

data/test/integration/foreman_puppet/smartclass_parameter_js_test.rb

@@ -0,0 +1,84 @@
+require_relative '../../test_puppet_helper'
+require 'integration_test_helper'
+
+module ForemanPuppet
+  class SmartclassParameterJSTest < IntegrationTestWithJavascript
+    include ForemanPuppet::Engine.routes.url_helpers
+
+    # intermittent failures:
+    #   PuppetclassLookupKeyJSTest.test_0001_can hide value when overriden
+    #   PuppetclassLookupKeyJSTest.test_0002_uncheck override
+
+    test 'index page' do
+      FactoryBot.create(:puppetclass_lookup_key, key: 'ssl')
+      assert_index_page(puppetclass_lookup_keys_path, 'Smart Class Parameters', false)
+    end
+
+    test 'can hide value when overriden' do
+      FactoryBot.create(:puppetclass_lookup_key, key: 'port', override: false)
+      visit puppetclass_lookup_keys_path
+      within(:xpath, '//table') do
+        click_link 'port'
+      end
+      page.find('#puppetclass_lookup_key_override').click
+      assert page.find('#puppetclass_lookup_key_hidden_value:enabled')
+    end
+
+    test 'does not turn empty boolean value to false' do
+      FactoryBot.create(:puppetclass_lookup_key, key: 'ssl')
+      visit puppetclass_lookup_keys_path
+      within(:xpath, '//table') do
+        click_link 'ssl'
+      end
+
+      page.find('.add_nested_fields').click
+      row = page.first('.lookup_values table tbody tr')
+      row.find('.matcher_key').select('os')
+      row.find('.matcher_value').set('fake')
+      wait_for_ajax
+
+      click_button('Submit')
+      assert page.has_selector?('.has-error')
+    end
+
+    test 'uncheck override' do
+      FactoryBot.create(:puppetclass_lookup_key, key: 'ssl')
+      visit puppetclass_lookup_keys_path
+      within(:xpath, '//table') do
+        click_link 'ssl'
+      end
+
+      page.find('#puppetclass_lookup_key_hidden_value').click
+
+      assert_submit_button(puppetclass_lookup_keys_path)
+      wait_for_ajax
+
+      within(:xpath, '//table') do
+        click_link 'ssl'
+      end
+
+      page.find('#puppetclass_lookup_key_override').click
+
+      assert_submit_button(puppetclass_lookup_keys_path)
+      wait_for_ajax
+
+      within(:xpath, '//table') do
+        click_link 'ssl'
+      end
+
+      assert page.find('#puppetclass_lookup_key_hidden_value').checked?
+    end
+
+    test 'edit page' do
+      FactoryBot.create(:puppetclass_lookup_key, key: 'ssl')
+      visit puppetclass_lookup_keys_path
+      within(:xpath, '//table') do
+        click_link 'ssl'
+      end
+      fill_in 'puppetclass_lookup_key_description', with: 'test'
+      fill_in 'puppetclass_lookup_key_default_value', with: 'false'
+      assert_submit_button(puppetclass_lookup_keys_path)
+      assert page.has_link? 'ssl'
+    end
+  end
+end

data/test/models/foreman_puppet/config_group_class_test.rb

@@ -0,0 +1,9 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  class ConfigGroupClassTest < ActiveSupport::TestCase
+    should validate_presence_of(:config_group)
+    should validate_presence_of(:puppetclass)
+    should validate_uniqueness_of(:config_group).scoped_to(:puppetclass_id)
+  end
+end

data/test/models/foreman_puppet/config_group_test.rb

@@ -0,0 +1,8 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  class ConfigGroupTest < ActiveSupport::TestCase
+    should validate_presence_of(:name)
+    should validate_uniqueness_of(:name)
+  end
+end

data/test/models/foreman_puppet/environment_test.rb

@@ -0,0 +1,92 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  class EnvironmentTest < ActiveSupport::TestCase
+    should validate_presence_of(:name)
+    should validate_uniqueness_of(:name)
+    should have_many(:provisioning_templates).through(:template_combinations)
+    should have_many(:puppetclasses).through(:environment_classes)
+
+    test 'to_label should print name' do
+      env = Environment.new name: 'foo'
+      assert_equal env.to_label, env.name
+    end
+
+    test 'to_s should print name' do
+      env = Environment.new name: 'foo'
+      assert_equal env.to_s, env.name
+    end
+
+    test 'should create environment with the name "new"' do
+      assert FactoryBot.build_stubbed(:environment, name: 'new').valid?
+    end
+
+    test 'should create with multiple valid names' do
+      valid_env_name_list.each do |name|
+        env = FactoryBot.build(:environment, name: name)
+        assert env.valid?, "Can't create environment with valid name #{name}"
+      end
+    end
+
+    test 'should not create with multiple invalid names' do
+      invalid_env_name_list.each do |name|
+        env = FactoryBot.build(:environment, name: name)
+        assert_not env.valid?, "Can create environment with invalid name #{name}"
+        assert_includes env.errors.keys, :name
+      end
+    end
+
+    test 'should update with multiple valid names' do
+      env = FactoryBot.create(:environment)
+      valid_env_name_list.each do |name|
+        env.name = name
+        assert env.valid?, "Can't update environment with valid name #{name}"
+      end
+    end
+
+    test 'should not update with multiple invalid names' do
+      env = FactoryBot.create(:environment)
+      invalid_env_name_list.each do |name|
+        env.name = name
+        assert_not env.valid?, "Can update environment with invalid name #{name}"
+        assert_includes env.errors.keys, :name
+      end
+    end
+
+    context 'audited' do
+      test 'on creation on of a new environment' do
+        environment = FactoryBot.build(:environment, :with_auditing)
+
+        assert_difference 'environment.audits.count' do
+          environment.save!
+        end
+      end
+    end
+
+    private
+
+    # List of valid environment names.
+    def valid_env_name_list
+      [
+        RFauxFactory.gen_alphanumeric(1),
+        RFauxFactory.gen_alphanumeric(255),
+        RFauxFactory.gen_alphanumeric(rand(1..254)),
+        RFauxFactory.gen_alpha(rand(1..254)),
+        RFauxFactory.gen_numeric_string(rand(1..254)),
+      ]
+    end
+
+    # List of invalid environment names.
+    def invalid_env_name_list
+      [
+        RFauxFactory.gen_cjk,
+        RFauxFactory.gen_latin1,
+        RFauxFactory.gen_utf8,
+        RFauxFactory.gen_alpha(256),
+        RFauxFactory.gen_numeric_string(256),
+        RFauxFactory.gen_alphanumeric(256),
+        RFauxFactory.gen_html(249),
+      ]
+    end
+  end
+end

data/test/models/foreman_puppet/host_config_group_test.rb

@@ -0,0 +1,39 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  class HostConfigGroupTest < ActiveSupport::TestCase
+    should belong_to(:host)
+    should belong_to(:config_group)
+    should validate_uniqueness_of(:host_id).scoped_to(:config_group_id, :host_type)
+
+    let(:environment) { FactoryBot.create(:environment) }
+    let(:puppetclasses) { FactoryBot.create_list(:puppetclass, 4, environments: [environment]) }
+    let(:config_group_with_classes) { FactoryBot.create(:config_group, puppetclasses: puppetclasses) }
+
+    test 'relationship host.group_puppetclasses' do
+      host = FactoryBot.create(:host, :with_puppet_enc, config_groups: [config_group_with_classes])
+      assert_equal 4, host.puppet.group_puppetclasses.count
+      assert_equal puppetclasses.map(&:id).sort, host.puppet.group_puppetclasses.pluck(:id).sort
+    end
+
+    test 'relationship host.config_groups ' do
+      cgs = FactoryBot.create_list(:config_group, 2)
+      host = FactoryBot.create(:host, :with_puppet_enc, config_groups: cgs)
+      assert_equal 2, host.puppet.config_groups.count
+      assert_equal cgs.map(&:name).sort, host.puppet.config_groups.pluck(:name).sort
+    end
+
+    test 'relationship hostgroup.group_puppetclasses' do
+      hostgroup = FactoryBot.create(:hostgroup, :with_puppet_enc, config_groups: [config_group_with_classes])
+      assert_equal 4, hostgroup.puppet.group_puppetclasses.count
+      assert_equal puppetclasses.map(&:id).sort, hostgroup.puppet.group_puppetclasses.pluck(:id).sort
+    end
+
+    test 'relationship hostgroup.config_groups' do
+      cgs = FactoryBot.create_list(:config_group, 2)
+      hostgroup = FactoryBot.create(:hostgroup, :with_puppet_enc, config_groups: cgs)
+      assert_equal 2, hostgroup.puppet.config_groups.count
+      assert_equal cgs.map(&:name).sort, hostgroup.puppet.config_groups.pluck(:name).sort
+    end
+  end
+end

data/test/models/foreman_puppet/host_puppet_facet_test.rb

@@ -0,0 +1,116 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  class HostgroupPuppetFacetTest < ActiveSupport::TestCase
+    let(:environment) { FactoryBot.create(:environment) }
+    let(:diff_environment) { FactoryBot.create(:environment) }
+    let(:puppetclass_both) { FactoryBot.create(:puppetclass, environments: [environment, diff_environment]) }
+    let(:config_group) { FactoryBot.create(:config_group, :with_puppetclass, class_environments: [environment]) }
+    let(:config_group_diff_env) { FactoryBot.create(:config_group, :with_puppetclass, class_environments: [diff_environment]) }
+
+    describe '#classes_in_groups' do
+      test 'classes_in_groups should return the puppetclasses of a config group only if it is in host environment' do
+        host = FactoryBot.create(:host, :with_puppet_enc,
+          location: taxonomies(:location1),
+          organization: taxonomies(:organization1),
+          environment: environment,
+          config_groups: [config_group, config_group_diff_env])
+        group_classes = host.puppet.classes_in_groups
+        assert_equal config_group.puppetclasses.pluck(:id).sort, group_classes.map(&:id).sort
+      end
+    end
+
+    describe '#all_puppetclasses' do
+      test 'should return all classes for environment only' do
+        host = FactoryBot.create(:host, :with_puppet_enc,
+          location: taxonomies(:location1),
+          organization: taxonomies(:organization1),
+          environment: environment,
+          config_groups: [config_group, config_group_diff_env],
+          puppetclasses: [puppetclass_both])
+        all_classes = host.puppet.classes
+        # four classes in config groups plus one manually added
+        assert_equal 2, all_classes.count
+        assert_equal [puppetclass_both.id, config_group.puppetclass_ids.first].sort, all_classes.map(&:id).sort
+        assert_equal all_classes, host.puppet.all_puppetclasses
+      end
+    end
+
+    describe '#parent_classes' do
+      test 'should return parent_classes if host has hostgroup and environment are the same' do
+        hostgroup        = FactoryBot.create(:hostgroup, :with_puppet_enc, :with_puppetclass)
+        host             = FactoryBot.create(:host, :with_puppet_enc, hostgroup: hostgroup, environment: hostgroup.puppet.environment)
+        assert host.hostgroup
+        assert_not_empty host.puppet.parent_classes
+        assert_equal host.puppet.parent_classes, host.hostgroup.puppet.classes
+      end
+
+      test 'should not return parent classes that do not match environment' do
+        # one class in the right env, one in a different env
+        pclass2 = FactoryBot.create(:puppetclass, environments: [diff_environment])
+        hostgroup = FactoryBot.create(:hostgroup, :with_puppet_enc, puppetclasses: [puppetclass_both, pclass2], environment: environment)
+        host = FactoryBot.create(:host, :with_puppet_enc, hostgroup: hostgroup, environment: diff_environment)
+        assert host.hostgroup
+        assert_not_empty host.puppet.parent_classes
+        assert_not_equal host.puppet.environment, host.hostgroup.puppet.environment
+        assert_not_equal host.puppet.parent_classes, host.hostgroup.puppet.classes
+      end
+
+      test 'should return empty array if host does not have hostgroup' do
+        host = FactoryBot.create(:host, :with_puppet_enc)
+        assert_nil host.hostgroup
+        assert_empty host.puppet.parent_classes
+      end
+    end
+
+    describe '#parent_config_groups' do
+      test 'should return parent config_groups if host has hostgroup' do
+        hostgroup        = FactoryBot.create(:hostgroup, :with_puppet_enc, :with_config_group)
+        host             = FactoryBot.create(:host, :with_puppet_enc, hostgroup: hostgroup, environment: hostgroup.puppet.environment)
+        assert host.hostgroup
+        assert_equal host.puppet.parent_config_groups, host.hostgroup.puppet.config_groups
+      end
+
+      test 'should return empty array if host has no hostgroup' do
+        host = FactoryBot.create(:host, :with_puppet_enc)
+        assert_not host.hostgroup
+        assert_empty host.puppet.parent_config_groups
+      end
+    end
+
+    describe '#individual_puppetclasses' do
+      test 'individual puppetclasses added to host (that can be removed) does not include classes that are included by config group' do
+        host   = FactoryBot.create(:host, :with_puppet_enc, :with_config_group)
+        pclass = FactoryBot.create(:puppetclass, environments: [host.puppet.environment])
+        host.puppet.puppetclasses << pclass
+        # not sure why, but .classes and .puppetclasses don't return the same thing here...
+        assert_equal (host.puppet.config_groups.first.classes + [pclass]).map(&:name).sort, host.puppet.classes.map(&:name).sort
+        assert_equal [pclass.name], host.puppet.individual_puppetclasses.map(&:name)
+      end
+    end
+
+    describe '#available_puppetclasses' do
+      test 'available_puppetclasses should return all if no environment' do
+        host = FactoryBot.create(:host, :with_puppet_enc)
+        host.puppet.update(environment_id: nil)
+        assert_equal ForemanPuppet::Puppetclass.where(nil), host.puppet.available_puppetclasses
+      end
+
+      test 'available_puppetclasses should return environment-specific classes' do
+        puppetclass_both
+        host = FactoryBot.create(:host, :with_puppet_enc)
+        assert_not_equal ForemanPuppet::Puppetclass.where(nil), host.puppet.available_puppetclasses
+        assert_equal host.puppet.environment.puppetclasses.sort, host.puppet.available_puppetclasses.sort
+      end
+
+      test 'available_puppetclasses should return environment-specific classes (and that are NOT already inherited by parent)' do
+        puppetclass_both
+        hostgroup        = FactoryBot.create(:hostgroup, :with_puppet_enc, :with_puppetclass, environment: environment)
+        host             = FactoryBot.create(:host, :with_puppet_enc, hostgroup: hostgroup, environment: environment)
+        assert_not_equal ForemanPuppet::Puppetclass.where(nil), host.puppet.available_puppetclasses
+        assert_not_equal host.puppet.environment.puppetclasses.sort, host.puppet.available_puppetclasses.sort
+        assert_equal (host.puppet.environment.puppetclasses - host.puppet.parent_classes).sort, host.puppet.available_puppetclasses.sort
+      end
+    end
+  end
+end