foreman_puppet 1.0.5 → 2.0.3

data/package.json

@@ -21,25 +21,22 @@
     "url": "http://projects.theforeman.org/projects/foreman_puppet/issues"
   },
   "peerDependencies": {
-    "@theforeman/vendor": ">= 6.0.0"
+    "@theforeman/vendor": "^8.15.0"
   },
   "devDependencies": {
     "@babel/core": "^7.7.0",
     "@sheerun/mutationobserver-shim": "^0.3.3",
-    "@theforeman/builder": "^6.0.0",
-    "@theforeman/eslint-plugin-foreman": "^6.0.0",
-    "@theforeman/find-foreman": "^4.8.0",
-    "@theforeman/stories": "^7.0.0",
-    "@theforeman/test": "^8.0.0",
-    "@theforeman/vendor-dev": "^6.0.0",
+    "@theforeman/builder": "^8.15.0",
+    "@theforeman/eslint-plugin-foreman": "^8.15.0",
+    "@theforeman/find-foreman": "^8.15.0",
+    "@theforeman/stories": "^8.15.0",
+    "@theforeman/test": "^8.15.0",
+    "@theforeman/vendor-dev": "^8.15.0",
     "babel-eslint": "^10.0.3",
     "eslint": "^6.7.2",
+    "jed": "^1.1.1",
     "prettier": "^1.19.1",
     "stylelint-config-standard": "^18.0.0",
     "stylelint": "^9.3.0"
-  },
-  "dependencies": {
-    "jed": "^1.1.1",
-    "react-intl": "^2.8.0"
   }
 }

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

@@ -111,237 +111,6 @@ module ForemanPuppet
           end
           assert_response :success
         end
-
-        describe 'POST #import_puppetclasses' do
-          # puppetmaster proxy - import_puppetclasses tests
-
-          let(:proxy) { FactoryBot.create(:puppet_smart_proxy) }
-
-          test 'should import new environments' do
-            setup_import_classes
-            as_admin do
-              Host::Managed.update_all(environment_id: nil)
-              Hostgroup.update_all(environment_id: nil)
-              Puppetclass.destroy_all
-              Environment.destroy_all
-            end
-            assert_difference('Environment.unscoped.count', 2) do
-              post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
-            end
-            assert_response :success
-            response = ActiveSupport::JSON.decode(@response.body)
-            assert_equal 2, response['environments_with_new_puppetclasses']
-          end
-
-          # this is intentional: put test_attributes only for the first generated test eg: dryrun_param = {}
-          test_attributes pid: '385efd1b-6146-47bf-babf-0127ce5955ed'
-          [{}, { dryrun: false }, { dryrun: 'false' }].each do |dryrun_param|
-            test 'should import new puppetclasses' do
-              setup_import_classes
-              as_admin do
-                Host::Managed.update_all(environment_id: nil)
-                Hostgroup.update_all(environment_id: nil)
-                Puppetclass.destroy_all
-                Environment.destroy_all
-                assert_difference(-> { ForemanPuppet::Puppetclass.unscoped.count }, 1) do
-                  post :import_puppetclasses,
-                    params: { id: proxy.id }.merge(dryrun_param),
-                    session: set_session_user
-                end
-              end
-              assert_response :success
-              assert_match 'Successfully updated environment and puppetclasses from the on-disk puppet installation', @response.body
-            end
-          end
-
-          test 'should not import new puppetclasses when dryrun' do
-            setup_import_classes
-            as_admin do
-              Host::Managed.update_all(environment_id: nil)
-              Hostgroup.update_all(environment_id: nil)
-              Puppetclass.destroy_all
-              Environment.destroy_all
-              assert_difference(-> { ForemanPuppet::Puppetclass.unscoped.count }, 0) do
-                post :import_puppetclasses, params: { id: proxy.id, dryrun: true }, session: set_session_user
-              end
-            end
-            assert_response :success
-          end
-
-          test 'should obsolete environment' do
-            setup_import_classes
-            as_admin do
-              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
-            setup_import_classes
-            as_admin do
-              assert_difference(-> { ForemanPuppet::Environment.unscoped.find_by(name: 'env1').puppetclasses.count }, -2) do
-                post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
-              end
-            end
-            assert_response :success
-          end
-
-          test 'should update puppetclass smart class parameters' do
-            setup_import_classes
-            LookupKey.destroy_all
-            assert_difference(-> { LookupKey.unscoped.count }, 1) do
-              post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
-            end
-            assert_response :success
-          end
-
-          test 'no changes on import_puppetclasses' do
-            setup_import_classes
-            Puppetclass.find_by(name: 'b').destroy
-            Puppetclass.find_by(name: 'c').destroy
-            assert_difference(-> { ForemanPuppet::Environment.unscoped.count }, 0) do
-              post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
-            end
-            assert_response :success
-            response = ActiveSupport::JSON.decode(@response.body)
-            assert_equal 'Successfully updated environment and puppetclasses from the on-disk puppet installation', response['message']
-          end
-
-          test 'should import new environment that does not exist in db' do
-            setup_import_classes
-            as_admin do
-              env_name = 'env1'
-              assert Environment.find_by(name: env_name).destroy
-              assert_difference('Environment.unscoped.count', 1) do
-                post :import_puppetclasses, params: { id: proxy.id, environment_id: env_name }, session: set_session_user
-              end
-              assert_response :success
-              response = ActiveSupport::JSON.decode(@response.body)
-              assert_equal env_name, response['results']['name']
-            end
-          end
-
-          test 'should NOT delete environment if pass ?except=obsolete' do
-            setup_import_classes
-            as_admin do
-              Environment.create!(name: 'xyz')
-            end
-            assert_difference(-> { ForemanPuppet::Environment.unscoped.count }, 0) do
-              post :import_puppetclasses, params: { id: proxy.id, except: 'obsolete' }, session: set_session_user
-            end
-            assert_response :success
-          end
-
-          test 'should NOT add or update puppetclass smart class parameters if pass ?except=new,updated' do
-            setup_import_classes
-            LookupKey.destroy_all
-            assert_difference(-> { LookupKey.unscoped.count }, 0) do
-              post :import_puppetclasses, params: { id: proxy.id, except: 'new,updated' }, session: set_session_user
-            end
-            assert_response :success
-          end
-
-          context 'import puppetclasses' do
-            setup do
-              ProxyAPI::Puppet.any_instance.stubs(:environments).returns(%w[env1 env2])
-              classes_env1 = { 'a' => Foreman::ImporterPuppetclass.new('name' => 'a') }
-              classes_env2 = { 'b' => Foreman::ImporterPuppetclass.new('name' => 'b') }
-              ProxyAPI::Puppet.any_instance.stubs(:classes).returns(classes_env1.merge(classes_env2))
-              ProxyAPI::Puppet.any_instance.stubs(:classes).with('env1').returns(classes_env1)
-              ProxyAPI::Puppet.any_instance.stubs(:classes).with('env2').returns(classes_env2)
-            end
-
-            test 'should render templates according to api version 2' do
-              post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
-              assert_template 'foreman_puppet/api/v2/import_puppetclasses/index'
-            end
-
-            test 'should import puppetclasses for specified environment only' do
-              assert_difference(-> { ForemanPuppet::Puppetclass.unscoped.count }, 1) do
-                post :import_puppetclasses, params: { id: proxy.id, environment_id: 'env1' }, session: set_session_user
-                assert_includes Puppetclass.pluck(:name), 'a'
-                assert_not_includes Puppetclass.pluck(:name), 'b'
-              end
-              assert_response :success
-            end
-
-            test 'should import puppetclasses for all environments if none specified' do
-              assert_difference(-> { ForemanPuppet::Puppetclass.unscoped.count }, 2) do
-                post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
-              end
-              assert_includes Puppetclass.pluck(:name), 'a'
-              assert_includes Puppetclass.pluck(:name), 'b'
-              assert_response :success
-            end
-
-            context 'ignored entvironments or classes are set' do
-              setup do
-                setup_import_classes
-              end
-
-              test 'should contain ignored environments' do
-                env_name = 'env1'
-                PuppetClassImporter.any_instance.stubs(:ignored_environments).returns([env_name])
-
-                as_admin do
-                  post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
-                  assert_response :success
-                  response = ActiveSupport::JSON.decode(@response.body)
-                  assert_equal env_name, response['results'][0]['ignored_environment']
-                end
-              end
-
-              test 'should contain ignored puppet_classes' do
-                PuppetClassImporter.any_instance.stubs(:ignored_classes).returns([/^a$/])
-
-                as_admin do
-                  post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
-                  assert_response :success
-                  response = ActiveSupport::JSON.decode(@response.body)
-                  assert_includes response['results'][0]['ignored_puppetclasses'], 'a'
-                  assert_not_includes response['results'][0]['ignored_puppetclasses'], 'c'
-                end
-              end
-            end
-          end
-        end
-
-        private
-
-        def setup_import_classes
-          as_admin do
-            ::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| ForemanPuppet::Puppetclass.create name: name }
-            %w[env1 env2].each do |name|
-              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 = 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
       end
     end
   end

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

@@ -0,0 +1,255 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  module Api
+    module V2
+      class SmartProxiesControllerTest < ActionController::TestCase
+        tests ::Api::V2::SmartProxiesController
+
+        describe 'POST #import_puppetclasses' do
+          # puppetmaster proxy - import_puppetclasses tests
+
+          let(:proxy) { FactoryBot.create(:puppet_smart_proxy) }
+
+          test 'should import new environments' do
+            setup_import_classes
+            as_admin do
+              HostPuppetFacet.destroy_all
+              HostgroupPuppetFacet.destroy_all
+              Puppetclass.destroy_all
+              Environment.destroy_all
+            end
+            assert_difference('Environment.unscoped.count', 2) do
+              post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
+            end
+            assert_response :success
+            response = ActiveSupport::JSON.decode(@response.body)
+            assert_equal 2, response['environments_with_new_puppetclasses']
+          end
+
+          # this is intentional: put test_attributes only for the first generated test eg: dryrun_param = {}
+          test_attributes pid: '385efd1b-6146-47bf-babf-0127ce5955ed'
+          [{}, { dryrun: false }, { dryrun: 'false' }].each do |dryrun_param|
+            test 'should import new puppetclasses' do
+              setup_import_classes
+              as_admin do
+                HostPuppetFacet.destroy_all
+                HostgroupPuppetFacet.destroy_all
+                Puppetclass.destroy_all
+                Environment.destroy_all
+                assert_difference(-> { ForemanPuppet::Puppetclass.unscoped.count }, 1) do
+                  post :import_puppetclasses,
+                    params: { id: proxy.id }.merge(dryrun_param),
+                    session: set_session_user
+                end
+              end
+              assert_response :success
+              assert_match 'Successfully updated environment and puppetclasses from the on-disk puppet installation', @response.body
+            end
+          end
+
+          test 'should not import new puppetclasses when dryrun' do
+            setup_import_classes
+            as_admin do
+              HostPuppetFacet.destroy_all
+              HostgroupPuppetFacet.destroy_all
+              Puppetclass.destroy_all
+              Environment.destroy_all
+              assert_difference(-> { ForemanPuppet::Puppetclass.unscoped.count }, 0) do
+                post :import_puppetclasses, params: { id: proxy.id, dryrun: true }, session: set_session_user
+              end
+            end
+            assert_response :success
+          end
+
+          test 'should obsolete environment' do
+            setup_import_classes
+            as_admin do
+              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
+            setup_import_classes
+            as_admin do
+              assert_difference(-> { ForemanPuppet::Environment.unscoped.find_by(name: 'env1').puppetclasses.count }, -2) do
+                post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
+              end
+            end
+            assert_response :success
+          end
+
+          test 'should update puppetclass smart class parameters' do
+            setup_import_classes
+            LookupKey.destroy_all
+            assert_difference(-> { LookupKey.unscoped.count }, 1) do
+              post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
+            end
+            assert_response :success
+          end
+
+          test 'no changes on import_puppetclasses' do
+            setup_import_classes
+            Puppetclass.find_by(name: 'b').destroy
+            Puppetclass.find_by(name: 'c').destroy
+            assert_difference(-> { ForemanPuppet::Environment.unscoped.count }, 0) do
+              post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
+            end
+            assert_response :success
+            response = ActiveSupport::JSON.decode(@response.body)
+            assert_equal 'Successfully updated environment and puppetclasses from the on-disk puppet installation', response['message']
+          end
+
+          test 'should import new environment that does not exist in db' do
+            setup_import_classes
+            as_admin do
+              env_name = 'env1'
+              assert Environment.find_by(name: env_name).destroy
+              assert_difference('Environment.unscoped.count', 1) do
+                post :import_puppetclasses, params: { id: proxy.id, environment_id: env_name }, session: set_session_user
+              end
+              assert_response :success
+              response = ActiveSupport::JSON.decode(@response.body)
+              assert_equal env_name, response['results']['name']
+            end
+          end
+
+          test 'should NOT delete environment if pass ?except=obsolete' do
+            setup_import_classes
+            as_admin do
+              Environment.create!(name: 'xyz')
+            end
+            assert_difference(-> { ForemanPuppet::Environment.unscoped.count }, 0) do
+              post :import_puppetclasses, params: { id: proxy.id, except: 'obsolete' }, session: set_session_user
+            end
+            assert_response :success
+          end
+
+          test 'should NOT add or update puppetclass smart class parameters if pass ?except=new,updated' do
+            setup_import_classes
+            LookupKey.destroy_all
+            assert_difference(-> { LookupKey.unscoped.count }, 0) do
+              post :import_puppetclasses, params: { id: proxy.id, except: 'new,updated' }, session: set_session_user
+            end
+            assert_response :success
+          end
+
+          context 'import puppetclasses' do
+            setup do
+              ProxyAPI::Puppet.any_instance.stubs(:environments).returns(%w[env1 env2])
+              classes_env1 = { 'a' => Foreman::ImporterPuppetclass.new('name' => 'a') }
+              classes_env2 = { 'b' => Foreman::ImporterPuppetclass.new('name' => 'b') }
+
+              ProxyAPI::Puppet.any_instance.stubs(:classes).with('invalid').returns({})
+              ProxyAPI::Puppet.any_instance.stubs(:classes).with('env1').returns(classes_env1)
+              ProxyAPI::Puppet.any_instance.stubs(:classes).with('env2').returns(classes_env2)
+            end
+
+            test 'should render templates according to api version 2' do
+              post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
+              assert_template 'foreman_puppet/api/v2/import_puppetclasses/index'
+            end
+
+            test 'should import puppetclasses for specified environment only' do
+              assert_difference(-> { ForemanPuppet::Puppetclass.unscoped.count }, 1) do
+                post :import_puppetclasses, params: { id: proxy.id, environment_id: 'env1' }, session: set_session_user
+                assert_includes Puppetclass.pluck(:name), 'a'
+                assert_not_includes Puppetclass.pluck(:name), 'b'
+              end
+              assert_response :success
+            end
+
+            test 'should render error message when invalid environment is set' do
+              env = 'invalid'
+              assert_difference(-> { ForemanPuppet::Puppetclass.unscoped.count }, 0) do
+                post :import_puppetclasses, params: { id: proxy.id, environment_id: env }, session: set_session_user
+                assert_not_includes Puppetclass.pluck(:name), 'a'
+                assert_not_includes Puppetclass.pluck(:name), 'b'
+              end
+              response = ActiveSupport::JSON.decode(@response.body)
+              assert_equal 'The requested environment cannot be found.', response['message']
+              assert_response :success
+            end
+
+            test 'should import puppetclasses for all environments if none specified' do
+              assert_difference(-> { ForemanPuppet::Puppetclass.unscoped.count }, 2) do
+                post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
+              end
+              assert_includes Puppetclass.pluck(:name), 'a'
+              assert_includes Puppetclass.pluck(:name), 'b'
+              assert_response :success
+            end
+
+            context 'ignored environments or classes are set' do
+              setup do
+                setup_import_classes
+              end
+
+              test 'should contain ignored environments' do
+                env_name = 'env1'
+                PuppetClassImporter.any_instance.stubs(:ignored_environments).returns([env_name])
+
+                as_admin do
+                  post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
+                  assert_response :success
+                  response = ActiveSupport::JSON.decode(@response.body)
+                  assert_equal env_name, response['results'][0]['ignored_environment']
+                end
+              end
+
+              test 'should contain ignored puppet_classes' do
+                PuppetClassImporter.any_instance.stubs(:ignored_classes).returns([/^a$/])
+
+                as_admin do
+                  post :import_puppetclasses, params: { id: proxy.id }, session: set_session_user
+                  assert_response :success
+                  response = ActiveSupport::JSON.decode(@response.body)
+                  assert_includes response['results'][0]['ignored_puppetclasses'], 'a'
+                  assert_not_includes response['results'][0]['ignored_puppetclasses'], 'c'
+                end
+              end
+            end
+          end
+        end
+
+        private
+
+        def setup_import_classes
+          as_admin do
+            HostPuppetFacet.destroy_all
+            HostgroupPuppetFacet.destroy_all
+            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| ForemanPuppet::Puppetclass.create name: name }
+            %w[env1 env2].each do |name|
+              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 = 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
+      end
+    end
+  end
+end

data/test/controllers/foreman_puppet/environments_controller_test.rb

@@ -194,8 +194,8 @@ module ForemanPuppet
 
       def setup_import_classes
         as_admin do
-          Host::Managed.all.each { |h| h.update(environment_id: nil) }
-          Hostgroup.all.each { |h| h.update(environment_id: nil) }
+          HostPuppetFacet.destroy_all
+          HostgroupPuppetFacet.destroy_all
           Puppetclass.destroy_all
           Environment.destroy_all
         end

data/test/controllers/foreman_puppet/hosts_controller_test.rb

@@ -48,7 +48,6 @@ module ForemanPuppet
       setup { @routes = Rails.application.routes }
 
       test 'lookup value and description should be html escaped' do
-        skip 'Needs complete migration to be done' unless ForemanPuppet.extracted_from_core?
         FactoryBot.create(:puppetclass_lookup_key,
           default_value: "<script>alert('hacked!');</script>",
           description: "<script>alert('hacked!');</script>",

data/test/factories/foreman_puppet_factories.rb

@@ -105,8 +105,6 @@ 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

data/test/helpers/foreman_puppet/puppetclass_lookup_keys_helper_test.rb

@@ -0,0 +1,34 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  class PuppetclassLookupKeysHelperTest < ActionView::TestCase
+    include PuppetclassLookupKeysHelper
+
+    describe '#overridable_puppet_lookup_keys' do
+      let(:parent_puppet_var) { FactoryBot.create(:puppetclass_lookup_key) }
+      let(:parent_hg) { FactoryBot.create(:hostgroup, :with_puppet_enc, environment: parent_puppet_var.environments.first) }
+
+      context 'with new hostgroup' do
+        subject do
+          hg = Hostgroup.new(parent: parent_hg)
+          hg.build_puppet
+          hg
+        end
+
+        it 'returns inherited parameter' do
+          keys = overridable_puppet_lookup_keys(parent_puppet_var.param_classes.first, subject)
+          _(keys).must_include(parent_puppet_var)
+        end
+      end
+
+      context 'with new host' do
+        subject { Host.new(hostgroup: parent_hg) }
+
+        it 'returns inherited parameter' do
+          keys = overridable_puppet_lookup_keys(parent_puppet_var.param_classes.first, subject)
+          _(keys).must_include(parent_puppet_var)
+        end
+      end
+    end
+  end
+end

data/test/integration/foreman_puppet/dashboard_js_test.rb

@@ -0,0 +1,31 @@
+require 'test_puppet_helper'
+require 'integration_test_helper'
+require 'integration/shared/host_finders'
+require 'integration/shared/host_orchestration_stubs'
+
+module ForemanPuppet
+  class DashboardJSTest < IntegrationTestWithJavascript
+    setup do
+      Dashboard::Manager.reset_user_to_default(users(:admin))
+      Setting[:outofsync_interval] = 35
+    end
+
+    context 'with origin' do
+      setup do
+        Setting[:puppet_out_of_sync_disabled] = true
+      end
+
+      context 'out of sync disabled' do
+        test 'has no out of sync link' do
+          visit dashboard_path
+          wait_for_ajax
+          within "li[data-name='Host Configuration Status for Puppet']" do
+            assert page.has_no_link?('Out of sync hosts')
+            assert page.has_no_link?('Good host reports in the last')
+            assert page.has_link?('Good host with reports')
+          end
+        end
+      end
+    end
+  end
+end

data/test/integration/foreman_puppet/host_js_test.rb

@@ -362,7 +362,6 @@ module ForemanPuppet
       page.find('#puppet_klasses_parameters_table')
     end
 
-    # TODO: unless ForemanPuppet.extracted_from_core?
     def switch_form_tab_to_interfaces
       switch_form_tab('Interfaces')
       disable_interface_modal_animation

data/test/integration/foreman_puppet/puppetclass_js_test.rb

@@ -11,7 +11,7 @@ module ForemanPuppet
     let(:puppetclass) { FactoryBot.create(:puppetclass, environments: [environment]) }
 
     test 'edit page' do
-      FactoryBot.create(:puppetclass, name: 'vim', environments: [environment]) if ForemanPuppet.extracted_from_core?
+      FactoryBot.create(:puppetclass, name: 'vim', environments: [environment])
       visit puppetclasses_path
       click_link 'vim'
       assert page.has_no_link? 'Common'