foreman_puppet 0.1.0 → 1.0.0.rc.1

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,22 +315,22 @@ 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
@@ -336,7 +338,7 @@ module ForemanPuppet
           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 = pcs.map { |k| [k.keys.first, Foreman::ImporterPuppetclass.new(k.values.first)] }.to_h
-          Environment.expects(:puppetEnvs).returns(envs).at_least(0)
+          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

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/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
 

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/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,66 @@
+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],
+          }
+        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!],
+              ) {
+              createHost(input: {
+                name: $name,
+                environmentId: $environmentId,
+                puppetclassIds: $puppetclassIds,
+              }) {
+                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_not_nil data
+          end
+        end
+      end
+    end
+  end
+end

data/test/graphql/queries/environment_query_test.rb

@@ -0,0 +1,54 @@
+require 'test_puppet_helper'
+
+module Queries
+  class EnvironmentQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query (
+        $id: String!
+      ) {
+        environment(id: $id) {
+          id
+          createdAt
+          updatedAt
+          name
+          locations {
+            totalCount
+            edges {
+              node {
+                id
+              }
+            }
+          }
+          organizations {
+            totalCount
+            edges {
+              node {
+                id
+              }
+            }
+          }
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:environment) { FactoryBot.create(:environment) }
+
+    let(:global_id) { Foreman::GlobalId.for(environment) }
+    let(:variables) { { id: global_id } }
+    let(:data) { result['data']['environment'] }
+
+    test 'fetching environment attributes' do
+      assert_empty result['errors']
+
+      assert_equal global_id, data['id']
+      assert_equal environment.created_at.utc.iso8601, data['createdAt']
+      assert_equal environment.updated_at.utc.iso8601, data['updatedAt']
+      assert_equal environment.name, data['name']
+
+      assert_collection environment.locations, data['locations']
+      assert_collection environment.organizations, data['organizations']
+    end
+  end
+end

data/test/graphql/queries/environments_query_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+module Queries
+  class EnvironmentsQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query {
+        environments {
+          totalCount
+          pageInfo {
+            startCursor
+            endCursor
+            hasNextPage
+            hasPreviousPage
+          }
+          edges {
+            cursor
+            node {
+              id
+            }
+          }
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:data) { result['data']['environments'] }
+
+    setup do
+      FactoryBot.create_list(:environment, 2)
+    end
+
+    test 'fetching environments attributes' do
+      assert_empty result['errors']
+
+      expected_count = ForemanPuppet::Environment.count
+
+      assert_not_equal 0, expected_count
+      assert_equal expected_count, data['totalCount']
+      assert_equal expected_count, data['edges'].count
+    end
+  end
+end