foreman_puppet 0.0.2 → 1.0.0

data/locale/foreman_puppet.pot

@@ -8,8 +8,8 @@ msgid ""
 msgstr ""
 "Project-Id-Version: foreman_puppet 1.0.0\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2021-02-02 04:11+0100\n"
-"PO-Revision-Date: 2021-02-02 04:11+0100\n"
+"POT-Creation-Date: 2021-02-03 18:00+0100\n"
+"PO-Revision-Date: 2021-02-03 18:00+0100\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
 "Language: \n"
@@ -1071,6 +1071,22 @@ msgstr ""
 msgid "Loading parameters..."
 msgstr ""
 
+#: action_names.rb:2
+msgid "Action with sub plans"
+msgstr ""
+
+#: action_names.rb:3
+msgid "Import facts"
+msgstr ""
+
+#: action_names.rb:4
+msgid "Import Puppet classes"
+msgstr ""
+
+#: action_names.rb:5
+msgid "Remote action:"
+msgstr ""
+
 #: gemspec.rb:2
-msgid "TODO: Description of ForemanPuppetEnc."
+msgid "Allow assigning Puppet environmets and classes to the Foreman Hosts."
 msgstr ""

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

@@ -6,18 +6,22 @@ module ForemanPuppet
         setup do
           @routes = ForemanPuppet::Engine.routes
         end
+
+        let(:puppetclasses) { FactoryBot.create_list(:puppetclass, 2) }
+        let(:config_group) { FactoryBot.create(:config_group) }
+
         test 'should create config group' do
           assert_difference('ConfigGroup.count') do
-            post :create, params: { config_group: { name: 'config-group', puppetclass_ids: [puppetclasses(:one).id, puppetclasses(:four).id] } }
+            post :create, params: { config_group: { name: 'config-group', puppetclass_ids: puppetclasses.map(&:id) } }
           end
           assert_response :created
         end
 
         test 'should update config group' do
           name = 'new name'
-          put :update, params: { id: config_groups(:one).to_param,
+          put :update, params: { id: config_group.to_param,
                                  config_group: { name: name,
-                                                 puppetclass_ids: [puppetclasses(:one).id, puppetclasses(:four).id] } }
+                                                 puppetclass_ids: puppetclasses.map(&:id) } }
           assert_response :success
           response = JSON.parse(@response.body)
           assert_equal 2, response['puppetclasses'].count

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

@@ -106,7 +106,7 @@ module ForemanPuppet
 
         test 'should destroy environments' do
           environment
-          assert_difference('Environment.unscoped.count', -1) do
+          assert_difference(-> { ForemanPuppet::Environment.unscoped.count }, -1) do
             delete :destroy, params: { id: environment.to_param }
           end
           assert_response :success
@@ -171,12 +171,14 @@ module ForemanPuppet
           test 'should obsolete environment' do
             setup_import_classes
             as_admin do
-              Environment.create!(name: 'xyz')
-            end
-            assert_difference(-> { ForemanPuppet::Environment.unscoped.count }, -1) do
-              post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
+              FactoryBot.create(:environment, name: 'xyz')
             end
+
+            post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
             assert_response :success
+            as_admin do
+              assert_nil ForemanPuppet::Environment.find_by(name: 'xyz')
+            end
           end
 
           test 'should obsolete puppetclasses' do
@@ -313,30 +315,30 @@ module ForemanPuppet
 
         def setup_import_classes
           as_admin do
-            Host::Managed.update_all(environment_id: nil)
-            Hostgroup.update_all(environment_id: nil)
-            HostClass.destroy_all
-            HostgroupClass.destroy_all
-            Puppetclass.destroy_all
-            Environment.destroy_all
+            ::Host::Managed.update_all(environment_id: nil)
+            ::Hostgroup.update_all(environment_id: nil)
+            ForemanPuppet::HostClass.destroy_all
+            ForemanPuppet::HostgroupClass.destroy_all
+            ForemanPuppet::Puppetclass.destroy_all
+            ForemanPuppet::Environment.destroy_all
           end
           orgs = [taxonomies(:organization1)]
           locs = [taxonomies(:location1)]
           # This is the database status
           # and should result in a db_tree of {"env1" => ["a", "b", "c"], "env2" => ["a", "b", "c"]}
           as_admin do
-            %w[a b c].each { |name| Puppetclass.create name: name }
+            %w[a b c].each { |name| ForemanPuppet::Puppetclass.create name: name }
             %w[env1 env2].each do |name|
-              e = Environment.create!(name: name, organizations: orgs, locations: locs)
-              e.puppetclasses = Puppetclass.all
+              e = ForemanPuppet::Environment.create!(name: name, organizations: orgs, locations: locs)
+              e.puppetclasses = ForemanPuppet::Puppetclass.all
             end
           end
           # This is the on-disk status
           # and should result in a disk_tree of {"env1" => ["a", "b", "c"],"env2" => ["a", "b", "c"]}
           envs = HashWithIndifferentAccess.new(env1: %w[a b c], env2: %w[a b c])
           pcs = [HashWithIndifferentAccess.new('a' => { 'name' => 'a', 'module' => nil, 'params' => { 'key' => 'special' } })]
-          classes = Hash[pcs.map { |k| [k.keys.first, Foreman::ImporterPuppetclass.new(k.values.first)] }]
-          Environment.expects(:puppetEnvs).returns(envs).at_least(0)
+          classes = pcs.map { |k| [k.keys.first, Foreman::ImporterPuppetclass.new(k.values.first)] }.to_h
+          ForemanPuppet::Environment.expects(:puppetEnvs).returns(envs).at_least(0)
           ProxyAPI::Puppet.any_instance.stubs(:environments).returns(%w[env1 env2])
           ProxyAPI::Puppet.any_instance.stubs(:classes).returns(classes)
         end

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

@@ -61,10 +61,11 @@ module ForemanPuppet
         end
 
         describe '#create' do
-          test 'should create with puppet proxy' do
+          test 'should create with puppet proxy and environment' 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 environment.name, JSON.parse(@response.body)['environment_name'], "Can't create host environment #{environment}"
             assert_equal puppet_proxy.name, JSON.parse(@response.body)['puppet_proxy']['name'], "Can't create host with puppet proxy #{puppet_proxy}"
           end
         end
@@ -92,7 +93,7 @@ module ForemanPuppet
             assert_response :success
             response = ActiveSupport::JSON.decode(@response.body)
             puppet_class = response['data']['classes'].keys
-            assert_equal host.puppetclasses.map(&:name), puppet_class
+            assert_equal host.puppet.puppetclasses.map(&:name), puppet_class
           end
         end
       end

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

@@ -3,7 +3,7 @@ require 'test_puppet_helper'
 module ForemanPuppet
   module Api
     module V2
-      class DummyLookupController < ForemanPuppet::Api::V2::LookupsCommonController
+      class DummyLookupController < ForemanPuppet::Api::V2::PuppetLookupsCommonController
         attr_accessor :params
       end
 

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

@@ -0,0 +1,32 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  module Api
+    module V2
+      class ProvisioningTemplatesControllerTest < ActionController::TestCase
+        tests ::Api::V2::ProvisioningTemplatesController
+
+        let(:environment) { FactoryBot.create(:environment) }
+
+        test 'should create provisioning template with template_combinations' do
+          name = RFauxFactory.gen_alpha
+          valid_attrs = {
+            name: name, template: RFauxFactory.gen_alpha, template_kind_id: template_kinds(:ipxe).id,
+            template_combinations_attributes: [
+              { hostgroup_id: hostgroups(:common).id, environment_id: environment.id },
+            ]
+          }
+          post :create, params: { provisioning_template: valid_attrs }
+          assert_response :created
+          response = ActiveSupport::JSON.decode(@response.body)
+          assert response.key?('id')
+          assert response.key?('template_combinations')
+          template_combinations = response['template_combinations']
+          assert_equal 1, template_combinations.length
+          template_combination = TemplateCombination.find(template_combinations[0]['id'])
+          assert_equal response['id'], template_combination.provisioning_template_id
+        end
+      end
+    end
+  end
+end

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

@@ -35,18 +35,21 @@ module ForemanPuppet
 
         context 'with taxonomy given' do
           test 'index should return puppetclasses only in Organization' do
+            puppetclass
             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
+            puppetclass
             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
+            puppetclass
             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

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

@@ -207,11 +207,17 @@ module ForemanPuppet
 
           test_attributes pid: 'd7b1c336-bd9f-40a3-a573-939f2a021cdc'
           test 'should not set merge overrides for non supported types' do
+            expected_error = if Gem::Version.new(SETTINGS[:version].notag) < Gem::Version.new('2.6')
+                               'Validation failed: Merge overrides can only be set for array or hash'
+                             else
+                               'Validation failed: Merge overrides can only be set for array, hash, json or yaml'
+                             end
+
             put :update, params: { id: lookup_key.id, smart_class_parameter: { override: true,
                                                                                default_value: RFauxFactory.gen_alpha,
                                                                                merge_overrides: true } }
             assert_response :internal_server_error, 'Can set merge overrides for non supported types'
-            assert_error_message('Validation failed: Merge overrides can only be set for array or hash')
+            assert_error_message(expected_error)
             assert_not(lookup_key.reload.merge_overrides)
           end
 

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

@@ -64,8 +64,8 @@ module ForemanPuppet
                                    environment_id: template_combination.environment.id, id: template_combination.id }
 
             json_response = ActiveSupport::JSON.decode(@response.body)
-            assert_equal(json_response['environment_id'], environment.id)
-            assert_equal(json_response['hostgroup_id'], hostgroups(:common).id)
+            assert_equal(environment.id, json_response['environment_id'])
+            assert_equal(hostgroups(:common).id, json_response['hostgroup_id'])
             assert_response :success
           end
 

data/test/controllers/foreman_puppet/config_groups_controller_test.rb

@@ -9,7 +9,10 @@ module ForemanPuppet
     basic_pagination_per_page_test
     basic_pagination_rendered_test
 
+    let(:config_group) { FactoryBot.create(:config_group) }
+
     test 'should get index' do
+      config_group
       get :index, session: set_session_user
       assert_response :success
       assert_not_empty assigns(:config_groups)
@@ -28,18 +31,19 @@ module ForemanPuppet
     end
 
     test 'should get edit' do
-      get :edit, params: { id: config_groups(:one) }, session: set_session_user
+      get :edit, params: { id: config_group }, session: set_session_user
       assert_response :success
     end
 
     test 'should update config_group' do
-      put :update, params: { id: config_groups(:one), config_group: { name: 'new name' } }, session: set_session_user
+      put :update, params: { id: config_group, config_group: { name: 'new name' } }, session: set_session_user
       assert_redirected_to config_groups_path
     end
 
     test 'should destroy config_group' do
+      config_group
       assert_difference('ForemanPuppet::ConfigGroup.count', -1) do
-        delete :destroy, params: { id: config_groups(:three) }, session: set_session_user
+        delete :destroy, params: { id: config_group }, session: set_session_user
       end
       assert_redirected_to config_groups_path
     end

data/test/controllers/foreman_puppet/environments_controller_test.rb

@@ -170,7 +170,7 @@ module ForemanPuppet
 
       test 'user with viewer rights should fail to edit an environment' do
         setup_user
-        get :edit, params: { id: environments(:production).name }, session: set_session_user.merge(user: users(:one).id)
+        get :edit, params: { id: FactoryBot.create(:environment).name }, session: set_session_user.merge(user: users(:one).id)
         assert_equal(403, @response.status)
       end
 
@@ -215,7 +215,7 @@ module ForemanPuppet
         # and should result in a disk_tree of {"env1" => ["a", "b", "c"],"env2" => ["a", "b", "c"]}
         envs = HashWithIndifferentAccess.new(env1: %w[a b c], env2: %w[a b c])
         pcs = [HashWithIndifferentAccess.new('a' => { 'name' => 'a', 'module' => '', 'params' => {} })]
-        classes = Hash[pcs.map { |k| [k.keys.first, Foreman::ImporterPuppetclass.new(k.values.first)] }]
+        classes = pcs.map { |k| [k.keys.first, Foreman::ImporterPuppetclass.new(k.values.first)] }.to_h
         Environment.expects(:puppetEnvs).returns(envs).at_least(0)
         ProxyAPI::Puppet.any_instance.stubs(:environments).returns(%w[env1 env2])
         ProxyAPI::Puppet.any_instance.stubs(:classes).returns(classes)

data/test/controllers/foreman_puppet/puppetclass_lookup_keys_controller_test.rb

@@ -4,10 +4,10 @@ module ForemanPuppet
   class PuppetclassLookupKeysControllerTest < ActionController::TestCase
     setup do
       @routes = ForemanPuppet::Engine.routes
-      @factory_options = [{ puppetclass: puppetclasses(:one), override: true, default_value: 'test' }]
+      @factory_options = [{ puppetclass: FactoryBot.create(:puppetclass), override: true, default_value: 'test' }]
     end
 
-    let(:lookup_key) { FactoryBot.create(:puppetclass_lookup_key, puppetclass: puppetclasses(:one), override: true) }
+    let(:lookup_key) { FactoryBot.create(:puppetclass_lookup_key, override: true) }
 
     basic_pagination_rendered_test
     basic_pagination_per_page_test

data/test/controllers/foreman_puppet/puppetclasses_controller_test.rb

@@ -60,23 +60,22 @@ module ForemanPuppet
 
       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)
+        host_puppetclass_ids = host.puppet.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
+                    host: { puppet: { puppetclass_ids: (host_puppetclass_ids + [puppetclass.id]) } } }
+        assert_difference(-> { ForemanPuppet::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
+                    hostgroup: { puppet: { puppetclass_ids: (hostgroup_puppetclass_ids + [puppetclass.id]) } } }
+        assert_difference(-> { ForemanPuppet::HostgroupClass.count }, 0) do
           post :parameters, params: params, session: set_session_user
         end
       end

data/test/factories/foreman_puppet_factories.rb

@@ -105,11 +105,14 @@ FactoryBot.define do
         evaluator.parameter_count.times do
           evaluator.environments.each do |env|
             FactoryBot.create :puppetclass_lookup_key, override: false, puppetclass: pc, environment: env
+            # for Host#managed validation, once extracted_from_core? we can remove
+            env.reload
           end
         end
       else
         evaluator.environments.each do |env|
           FactoryBot.create :environment_class, puppetclass: pc, environment: env unless env.nil?
+          env.reload
         end
       end
     end

data/test/factories/host_puppet_enhancements.rb

@@ -2,21 +2,21 @@ FactoryBot.modify do
   factory :host do
     trait :with_puppetclass do
       transient do
-        environment
+        environment { FactoryBot.create(:environment) }
         puppetclasses { [FactoryBot.create(:puppetclass, environments: [environment])] }
       end
     end
 
     trait :with_config_group do
       transient do
-        environment
+        environment { FactoryBot.create(:environment) }
         config_groups { [FactoryBot.create(:config_group, :with_puppetclass, class_environments: [environment])] }
       end
     end
 
     trait :with_puppet_enc do
       transient do
-        environment
+        environment { FactoryBot.create(:environment) }
         puppetclasses { [] }
         config_groups { [] }
       end
@@ -30,14 +30,14 @@ FactoryBot.modify do
   factory :hostgroup do
     trait :with_puppetclass do
       transient do
-        environment
+        environment { FactoryBot.create(:environment) }
         puppetclasses { [FactoryBot.create(:puppetclass, environments: [environment])] }
       end
     end
 
     trait :with_puppet_enc do
       transient do
-        environment
+        environment { FactoryBot.create(:environment) }
         puppetclasses { [] }
         config_groups { [] }
       end
@@ -49,7 +49,7 @@ FactoryBot.modify do
 
     trait :with_config_group do
       transient do
-        environment
+        environment { FactoryBot.create(:environment) }
         config_groups { [FactoryBot.create(:config_group, :with_puppetclass, class_environments: [environment])] }
       end
     end

data/test/graphql/mutations/hosts/create_mutation_test.rb

@@ -0,0 +1,87 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  module Mutations
+    module Hosts
+      class CreateMutationTest < GraphQLQueryTestCase
+        let(:hostname) { 'my-graphql-host' }
+        let(:tax_location) { FactoryBot.create(:location) }
+        let(:organization) { FactoryBot.create(:organization) }
+        let(:environment) { FactoryBot.create(:environment, locations: [tax_location], organizations: [organization]) }
+        let(:environment_id) { Foreman::GlobalId.for(environment) }
+        let(:puppetclass) { FactoryBot.create(:puppetclass) }
+        let(:puppetclass_id) { Foreman::GlobalId.for(puppetclass) }
+
+        let(:variables) do
+          {
+            name: hostname,
+            environmentId: environment_id,
+            puppetclassIds: [puppetclass_id],
+            interfacesAttributes: [
+              {
+                type: 'bond',
+                attachedTo: %w[eth0 eth1],
+                identifier: 'bond0',
+                primary: true,
+                provision: true,
+                managed: true,
+              },
+            ],
+          }
+        end
+        let(:context_user) { FactoryBot.create(:user, :admin, locations: [tax_location], organizations: [organization]) }
+        let(:data) { result['data']['createHost']['host'] }
+
+        let(:query) do
+          <<-GRAPHQL
+            mutation createHostMutation(
+                $name: String!,
+                $environmentId: ID,
+                $puppetclassIds: [ID!],
+                $interfacesAttributes: [InterfaceAttributesInput!]
+              ) {
+              createHost(input: {
+                name: $name,
+                environmentId: $environmentId,
+                puppetclassIds: $puppetclassIds,
+                interfacesAttributes: $interfacesAttributes,
+              }) {
+                host {
+                  id
+                },
+                errors {
+                  path
+                  message
+                }
+              }
+            }
+          GRAPHQL
+        end
+
+        setup :disable_orchestration
+
+        it 'creates a host with puppet parameters' do
+          assert_difference(-> { Host.count }, +1) do
+            assert_empty result['errors']
+            assert_empty result['data']['createHost']['errors']
+
+            host = Host.find(Foreman::GlobalId.decode(data['id'])[2])
+            assert_equal environment.id, host.puppet.environment_id
+            assert_equal [puppetclass.id], host.puppet.puppetclasses.pluck(:id)
+
+            assert_equal 1, host.interfaces.count
+            interface = host.interfaces.first
+            assert_equal 'Nic::Bond', interface.type
+            assert_equal 'eth0, eth1', interface.attached_to
+            assert_equal 'bond0', interface.identifier
+            assert interface.primary
+            assert interface.provision
+            assert interface.managed
+
+            assert_not_nil data
+          end
+        end
+      end
+    end
+  end
+end