puppet 6.26.0-x64-mingw32 → 7.0.0-x64-mingw32

data/spec/integration/application/lookup_spec.rb

@@ -7,7 +7,6 @@ describe 'lookup' do
   include PuppetSpec::Files
 
   context 'with an environment' do
-    let(:fqdn) { Puppet.runtime[:facter].value(:fqdn) }
     let(:env_name) { 'spec' }
     let(:env_dir) { tmpdir('environments') }
     let(:environment_files) do
@@ -45,20 +44,12 @@ describe 'lookup' do
     let(:app) { Puppet::Application[:lookup] }
     let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, env_name, 'modules')]) }
     let(:environments) { Puppet::Environments::Directories.new(populated_env_dir, []) }
-    let(:facts) { Puppet::Node::Facts.new("facts", {'my_fact' => 'my_fact_value'}) }
-    let(:cert) { pem_content('oid.pem') }
 
-    let(:node) { Puppet::Node.new('testnode', :facts => facts, :environment => env) }
     let(:populated_env_dir) do
       dir_contained_in(env_dir, environment_files)
       env_dir
     end
 
-    before do
-      stub_request(:get, "https://puppet:8140/puppet-ca/v1/certificate/#{fqdn}").to_return(body: cert)
-      allow(Puppet::Node::Facts.indirection).to receive(:find).and_return(facts)
-    end
-
     def lookup(key, options = {}, explain = false)
       key = [key] unless key.is_a?(Array)
       allow(app.command_line).to receive(:args).and_return(key)
@@ -99,41 +90,24 @@ describe 'lookup' do
       expect(lookup('a')).to eql('value a')
     end
 
-    it 'loads trusted information from the node certificate' do
-      allow(Puppet).to receive(:override).and_call_original
-      expect(Puppet).to receive(:override).with(trusted_information: an_object_having_attributes(
-        certname: fqdn,
-        extensions: { "1.3.6.1.4.1.34380.1.2.1.1" => "somevalue" }))
-
-      Puppet.settings[:node_terminus] = 'exec'
-      expect_any_instance_of(Puppet::Node::Exec).to receive(:find).and_return(node)
-      lookup('a', :compile => true)
-    end
-
     it 'loads external facts when running without --node' do
       expect(Puppet::Util).not_to receive(:skip_external_facts)
       expect(Facter).not_to receive(:load_external)
       lookup('a')
     end
 
-    describe 'when using --node' do
-      let(:fqdn) { 'random_node' }
-
-      it 'skips loading of external facts' do
-        app.options[:node] = fqdn
-
-        expect(Puppet::Node::Facts.indirection).to receive(:find).and_return(facts)
-        expect(Facter).to receive(:load_external).once.with(false)
-        expect(Facter).to receive(:load_external).once.with(true)
-        lookup('a')
-      end
+    it 'skip loading of external facts when run with --node' do
+      app.options[:node] = "random_node"
+      expect(Facter).to receive(:load_external).once.with(false)
+      expect(Facter).to receive(:load_external).once.with(true)
+      lookup('a')
     end
 
     context 'uses node_terminus' do
       require 'puppet/indirector/node/exec'
       require 'puppet/indirector/node/plain'
 
-      let(:node) { Puppet::Node.new('testnode', :facts => facts, :environment => env) }
+      let(:node) { Puppet::Node.new('testnode', :environment => env) }
 
       it ':plain without --compile' do
         Puppet.settings[:node_terminus] = 'exec'

data/spec/integration/application/module_spec.rb

@@ -65,25 +65,4 @@ describe 'puppet module', unless: Puppet::Util::Platform.jruby? do
        .and output(%r{Unable to verify the SSL certificate}).to_stderr
     end
   end
-
-  it 'prints the complete URL it tried to connect to' do
-    response_proc = -> (req, res) { res.status = 404 }
-
-    # create a temp cacert bundle
-    ssl_file = tmpfile('systemstore')
-    File.write(ssl_file, server.ca_cert)
-
-    Puppet::Util.withenv("SSL_CERT_FILE" => ssl_file) do
-      server.start_server(response_proc: response_proc) do |port|
-        Puppet[:module_repository] = "https://127.0.0.1:#{port}/bogus_test/puppet"
-
-        expect {
-          app.command_line.args = ['install', 'puppetlabs-bacula']
-          app.run
-        }.to exit_with(1)
-         .and output(%r{Notice: Downloading from https://127.0.0.1:#{port}}).to_stdout
-         .and output(%r{https://127.0.0.1:#{port}/bogus_test/puppet/v3/releases}).to_stderr
-      end
-    end
-  end
 end

data/spec/integration/application/plugin_spec.rb

@@ -2,14 +2,15 @@ require 'spec_helper'
 require 'puppet/face'
 require 'puppet_spec/puppetserver'
 
-describe "puppet plugin", unless: Puppet::Util::Platform.jruby? do
+describe "puppet plugin" do
   include_context "https client"
 
   let(:server) { PuppetSpec::Puppetserver.new }
   let(:plugin) { Puppet::Application[:plugin] }
   let(:response_body) { "[{\"path\":\"/etc/puppetlabs/code/environments/production/modules\",\"relative_path\":\".\",\"links\":\"follow\",\"owner\":0,\"group\":0,\"mode\":493,\"checksum\":{\"type\":\"ctime\",\"value\":\"{ctime}2020-03-06 20:14:25 UTC\"},\"type\":\"directory\",\"destination\":null}]" }
 
-  it "downloads from plugins, pluginsfacts and locales mounts" do
+  it "downloads from plugins, pluginsfacts and locales mounts when i18n is enabled" do
+    Puppet[:disable_i18n] = false
     current_version_handler = -> (req, res) {
       res['X-Puppet-Version'] = Puppet.version
       res['Content-Type'] = 'application/json'
@@ -28,6 +29,27 @@ describe "puppet plugin", unless: Puppet::Util::Platform.jruby? do
     end
   end
 
+  it "downloads from plugins, pluginsfacts but no locales mounts when i18n is disabled" do
+    Puppet[:disable_i18n] = true
+
+    current_version_handler = -> (req, res) {
+      res['X-Puppet-Version'] = Puppet.version
+      res['Content-Type'] = 'application/json'
+      res.body = response_body
+    }
+
+    server.start_server(mounts: {file_metadatas: current_version_handler}) do |port|
+      Puppet[:serverport] = port
+      expect {
+        plugin.command_line.args << 'download'
+        plugin.run
+      }.to exit_with(0)
+       .and output(matching(
+         "Downloaded these plugins: #{Regexp.escape(Puppet[:pluginfactdest])}, #{Regexp.escape(Puppet[:plugindest])}"
+       )).to_stdout
+    end
+  end
+
   it "downloads from plugins and pluginsfacts from older puppetservers" do
     no_locales_handler = -> (req, res) {
       res['X-Puppet-Version'] = '5.3.3' # locales mount was added in 5.3.4

data/spec/integration/configurer_spec.rb

@@ -23,7 +23,7 @@ describe Puppet::Configurer do
       expect(Puppet::Transaction::Report.indirection).to receive(:save) do |report, x|
         expect(report.time).to be_a(Time)
         expect(report.logs.length).to be > 0
-      end.twice
+      end
 
       Puppet[:report] = true
 
@@ -60,8 +60,7 @@ describe Puppet::Configurer do
       expect(summary["time"]["last_run"]).to be_between(t1, t2)
     end
 
-    it "applies a cached catalog if pluginsync fails when usecacheonfailure is true and environment is valid" do
-      expect(@configurer).to receive(:valid_server_environment?).and_return(true)
+    it "applies a cached catalog if pluginsync fails when usecacheonfailure is true" do
       Puppet[:ignore_plugin_errors] = false
 
       Puppet[:use_cached_catalog] = false
@@ -75,21 +74,6 @@ describe Puppet::Configurer do
       expect(report.cached_catalog_status).to eq('on_failure')
     end
 
-    it "applies a cached catalog if pluginsync fails when usecacheonfailure is true and environment is invalid" do
-      expect(@configurer).to receive(:valid_server_environment?).and_return(false)
-      Puppet[:ignore_plugin_errors] = false
-
-      Puppet[:use_cached_catalog] = false
-      Puppet[:usecacheonfailure] = true
-
-      report = Puppet::Transaction::Report.new
-      expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_raise(Puppet::Error, 'Cannot compile remote catalog')
-      expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(@catalog)
-
-      @configurer.run(pluginsync: true, report: report)
-      expect(report.cached_catalog_status).to eq('on_failure')
-    end
-
     describe 'resubmitting facts' do
       context 'when resubmit_facts is set to false' do
         it 'should not send data' do

data/spec/integration/defaults_spec.rb

@@ -36,6 +36,13 @@ describe "Puppet defaults" do
     end
   end
 
+  describe "when setting the :serverport" do
+    it "should also set the :masterport to the same value" do
+      Puppet.settings[:serverport] = 9000
+      expect(Puppet.settings[:masterport]).to eq(9000)
+    end
+  end
+
   describe "when setting the :factpath" do
     it "should add the :factpath to Facter's search paths" do
       expect(Facter).to receive(:search).with("/my/fact/path")
@@ -152,6 +159,10 @@ describe "Puppet defaults" do
     expect(Puppet.settings.value(:preferred_serialization_format)).to eq("json")
   end
 
+  it "should default to true the disable_i18n setting" do
+    expect(Puppet.settings.value(:disable_i18n)).to eq(true)
+  end
+
   it "should have a setting for determining the configuration version and should default to an empty string" do
     expect(Puppet.settings[:config_version]).to eq("")
   end
@@ -164,18 +175,18 @@ describe "Puppet defaults" do
 
     it "should use the default serverport value when report port is unspecified" do
       Puppet.settings[:serverport] = "1234"
-      expect(Puppet.settings[:report_port]).to eq("1234")
+      expect(Puppet.settings[:report_port]).to eq(1234)
     end
 
     it "should use the default masterport value when report port is unspecified" do
       Puppet.settings[:masterport] = "1234"
-      expect(Puppet.settings[:report_port]).to eq("1234")
+      expect(Puppet.settings[:report_port]).to eq(1234)
     end
 
     it "should use report_port when set" do
       Puppet.settings[:serverport] = "1234"
       Puppet.settings[:report_port] = "5678"
-      expect(Puppet.settings[:report_port]).to eq("5678")
+      expect(Puppet.settings[:report_port]).to eq(5678)
     end
   end
 

data/spec/integration/environments/settings_interpolation_spec.rb

@@ -9,6 +9,10 @@ describe "interpolating $environment" do
   let(:confdir) { Puppet[:confdir] }
   let(:cmdline_args) { ['--confdir', confdir, '--vardir', Puppet[:vardir], '--hiera_config', Puppet[:hiera_config]] }
 
+  before(:each) do
+    FileUtils.mkdir_p(confdir)
+  end
+
   shared_examples_for "a setting that does not interpolate $environment" do
 
     before(:each) do

data/spec/integration/http/client_spec.rb

@@ -151,16 +151,4 @@ describe Puppet::HTTP::Client, unless: Puppet::Util::Platform.jruby? do
       end
     end
   end
-
-  context 'ciphersuites' do
-    it "does not connect when using an SSLv3 ciphersuite", :if => Puppet::Util::Package.versioncmp(OpenSSL::OPENSSL_LIBRARY_VERSION.split[1], '1.1.1e') > 0 do
-      Puppet[:ciphers] = "DES-CBC3-SHA"
-
-      https_server.start_server do |port|
-        expect {
-          client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: root_context})
-        }.to raise_error(Puppet::HTTP::ConnectionError, /no cipher match|sslv3 alert handshake failure/)
-      end
-    end
-  end
 end

data/spec/integration/indirector/direct_file_server_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'matchers/include'
 
 require 'puppet/indirector/file_content/file'
 require 'puppet/indirector/file_metadata/file'
@@ -29,6 +30,7 @@ end
 
 describe Puppet::Indirector::DirectFileServer, " when interacting with FileServing::Fileset and the model" do
   include PuppetSpec::Files
+  include Matchers::Include
 
   matcher :file_with_content do |name, content|
     match do |actual|
@@ -50,7 +52,7 @@ describe Puppet::Indirector::DirectFileServer, " when interacting with FileServi
     terminus = Puppet::Indirector::FileContent::File.new
     request = terminus.indirection.request(:search, Puppet::Util.path_to_uri(path).to_s, nil, :recurse => true)
 
-    expect(terminus.search(request)).to contain_exactly(
+    expect(terminus.search(request)).to include_in_any_order(
       file_with_content(File.join(path, "one"), "one content"),
       file_with_content(File.join(path, "two"), "two content"),
       directory_named(path))

data/spec/integration/indirector/facts/facter_spec.rb

@@ -6,14 +6,13 @@ require 'puppet/indirector/facts/facter'
 describe Puppet::Node::Facts::Facter do
   include PuppetSpec::Files
   include PuppetSpec::Compiler
-  include PuppetSpec::Settings
 
   before :each do
     Puppet::Node::Facts.indirection.terminus_class = :facter
   end
 
   it "preserves case in fact values" do
-    Puppet.runtime[:facter].add(:downcase_test) do
+    Facter.add(:downcase_test) do
       setcode do
         "AaBbCc"
       end
@@ -34,9 +33,9 @@ describe Puppet::Node::Facts::Facter do
       FileUtils.mkdir_p(test_module)
 
       File.open(File.join(test_module, 'custom.rb'), 'wb') { |file| file.write(<<-EOF)}
-      Puppet.runtime[:facter].add(:custom) do
+      Facter.add(:custom) do
         setcode do
-          Puppet.runtime[:facter].value('puppetversion')
+          Facter.value('puppetversion')
         end
       end
       EOF
@@ -67,102 +66,49 @@ describe Puppet::Node::Facts::Facter do
     end
   end
 
-  context "adding facts" do
-    it "adds the puppetversion fact" do
-      allow(Facter).to receive(:reset)
-
-      cat = compile_to_catalog('notify { $::puppetversion: }',
-                               Puppet::Node.indirection.find('foo'))
-      expect(cat.resource("Notify[#{Puppet.version.to_s}]")).to be
-    end
-
-    context "when adding the agent_specified_environment fact" do
-      it "does not add the fact if the agent environment is not set" do
-        expect do
-          compile_to_catalog('notify { $::agent_specified_environment: }',
-                             Puppet::Node.indirection.find('foo'))
-        end.to raise_error(Puppet::PreformattedError)
-      end
-
-      it "does not add the fact if the agent environment is set in sections other than agent or main" do
-        set_puppet_conf(Puppet[:confdir], <<~CONF)
-        [user]
-        environment=bar
-        CONF
+  it "adds the puppetversion fact" do
+    allow(Facter).to receive(:reset)
 
-        Puppet.initialize_settings
-        expect do
-          compile_to_catalog('notify { $::agent_specified_environment: }',
+    cat = compile_to_catalog('notify { $::puppetversion: }',
                              Puppet::Node.indirection.find('foo'))
-        end.to raise_error(Puppet::PreformattedError)
-      end
-
-      it "adds the agent_specified_environment fact when set in the agent section in puppet.conf" do
-        set_puppet_conf(Puppet[:confdir], <<~CONF)
-        [agent]
-        environment=bar
-        CONF
-
-        Puppet.initialize_settings
-        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
-                                 Puppet::Node.indirection.find('foo'))
-        expect(cat.resource("Notify[bar]")).to be
-      end
-
-      it "prefers agent_specified_environment from main if set in section other than agent" do
-        set_puppet_conf(Puppet[:confdir], <<~CONF)
-        [main]
-        environment=baz
-
-        [user]
-        environment=bar
-        CONF
-
-        Puppet.initialize_settings
-        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
-                                 Puppet::Node.indirection.find('foo'))
-        expect(cat.resource("Notify[baz]")).to be
-      end
-
-      it "prefers agent_specified_environment from agent if set in multiple sections" do
-        set_puppet_conf(Puppet[:confdir], <<~CONF)
-        [main]
-        environment=baz
-
-        [agent]
-        environment=bar
-        CONF
-
-        Puppet.initialize_settings
-        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
-                                 Puppet::Node.indirection.find('foo'))
-        expect(cat.resource("Notify[bar]")).to be
-      end
+    expect(cat.resource("Notify[#{Puppet.version.to_s}]")).to be
+  end
 
-      it "adds the agent_specified_environment fact when set in puppet.conf" do
-        set_puppet_conf(Puppet[:confdir], 'environment=bar')
+  it "the agent_specified_environment fact is nil when not set" do
+    expect do
+      compile_to_catalog('notify { $::agent_specified_environment: }',
+                         Puppet::Node.indirection.find('foo'))
+    end.to raise_error(Puppet::PreformattedError)
+  end
 
-        Puppet.initialize_settings
-        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
-                                 Puppet::Node.indirection.find('foo'))
-        expect(cat.resource("Notify[bar]")).to be
-      end
+  it "adds the agent_specified_environment fact when set in puppet.conf" do
+    FileUtils.mkdir_p(Puppet[:confdir])
+    File.open(File.join(Puppet[:confdir], 'puppet.conf'), 'w') do |f|
+      f.puts("environment=bar")
+    end
 
-      it "adds the agent_specified_environment fact when set via command-line" do
-        Puppet.initialize_settings(['--environment', 'bar'])
-        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
-                                 Puppet::Node.indirection.find('foo'))
-        expect(cat.resource("Notify[bar]")).to be
-      end
+    Puppet.initialize_settings
+    cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+                             Puppet::Node.indirection.find('foo'))
+    expect(cat.resource("Notify[bar]")).to be
+  end
 
-      it "adds the agent_specified_environment fact, preferring cli, when set in puppet.conf and via command-line" do
-        set_puppet_conf(Puppet[:confdir], 'environment=bar')
+  it "adds the agent_specified_environment fact when set via command-line" do
+    Puppet.initialize_settings(['--environment', 'bar'])
+    cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+                             Puppet::Node.indirection.find('foo'))
+    expect(cat.resource("Notify[bar]")).to be
+  end
 
-        Puppet.initialize_settings(['--environment', 'baz'])
-        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
-                                 Puppet::Node.indirection.find('foo'))
-        expect(cat.resource("Notify[baz]")).to be
-      end
+  it "adds the agent_specified_environment fact, preferring cli, when set in puppet.conf and via command-line" do
+    FileUtils.mkdir_p(Puppet[:confdir])
+    File.open(File.join(Puppet[:confdir], 'puppet.conf'), 'w') do |f|
+      f.puts("environment=bar")
     end
+
+    Puppet.initialize_settings(['--environment', 'baz'])
+    cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+                             Puppet::Node.indirection.find('foo'))
+    expect(cat.resource("Notify[baz]")).to be
   end
 end

data/spec/integration/network/http_pool_spec.rb

@@ -81,16 +81,6 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
         end
       end
 
-      it "doesn't generate a Puppet::SSL::Host deprecation warning" do
-        server.start_server do |port|
-          http = connection(hostname, port)
-          res = http.get('/')
-          expect(res.code).to eq('200')
-        end
-
-        expect(@logs).to eq([])
-      end
-
       it "detects when the server has closed the connection and reconnects" do
         server.start_server do |port|
           http = connection(hostname, port)
@@ -101,17 +91,13 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
       end
     end
 
-    context "when using single use HTTPS connections" do
-      include_examples 'HTTPS client'
-    end
-
     context "when using persistent HTTPS connections" do
       around :each do |example|
-        pool = Puppet::Network::HTTP::Pool.new(15)
-        Puppet.override(:http_pool => pool) do
+        begin
           example.run
+        ensure
+          Puppet.runtime[:http].close
         end
-        pool.close
       end
 
       include_examples 'HTTPS client'
@@ -183,10 +169,6 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
     end
 
     describe Puppet::Network::HTTP::Connection do
-      it_behaves_like "an HttpPool connection", described_class, true
-    end
-
-    describe Puppet::Network::HTTP::ConnectionAdapter do
       it_behaves_like "an HttpPool connection", described_class, false
     end
   end

data/spec/integration/parser/catalog_spec.rb

@@ -48,44 +48,6 @@ describe "A catalog" do
         expect(resources_in(agent_catalog)).
           to include_in_order(*resources_in_declaration_order)
       end
-
-      it "does not contain unrealized, virtual resources" do
-        virtual_resources = ["Unrealized[unreal]", "Class[Unreal]"]
-
-        master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
-          class unreal { }
-          define unrealized() { }
-
-          class real {
-            @unrealized { "unreal": }
-            @class { "unreal": }
-          }
-
-          include real
-        EOM
-
-        expect(resources_in(master_catalog)).to_not include(*virtual_resources)
-        expect(resources_in(agent_catalog)).to_not include(*virtual_resources)
-      end
-
-      it "does not contain unrealized, exported resources" do
-        exported_resources = ["Unrealized[unreal]", "Class[Unreal]"]
-
-        master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
-          class unreal { }
-          define unrealized() { }
-
-          class real {
-            @@unrealized { "unreal": }
-            @@class { "unreal": }
-          }
-
-          include real
-        EOM
-
-        expect(resources_in(master_catalog)).to_not include(*exported_resources)
-        expect(resources_in(agent_catalog)).to_not include(*exported_resources)
-      end
     end
   end
 

data/spec/integration/parser/node_spec.rb

@@ -117,15 +117,6 @@ describe 'node statements' do
       expect(catalog).to have_resource('Notify[matched]')
     end
 
-    it 'selects a node that is a prefix of the agent name' do
-      Puppet[:strict_hostname_checking] = false
-      catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("node.name.com"))
-      node 'node.name' { notify { matched: } }
-      MANIFEST
-
-      expect(catalog).to have_resource('Notify[matched]')
-    end
-
     it 'does not treat regex symbols as a regex inside a string literal' do
       catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodexname"))
       node 'node.name' { notify { 'not matched': } }

data/spec/integration/parser/pcore_resource_spec.rb

@@ -68,16 +68,6 @@ describe 'when pcore described resources types are in use' do
                 end
               end
             RUBY
-            'cap.rb' => <<-EOF
-            module Puppet
-            Type.newtype(:cap, :is_capability => true) do
-              @doc = "Docs for capability"
-              @isomorphic = false
-              newproperty(:message) do
-                desc "Docs for 'message' property"
-              end
-            end;end
-            EOF
            } } },
         }
       }}})
@@ -126,24 +116,10 @@ describe 'when pcore described resources types are in use' do
         test3 { 'x/y':
           message => 'x/y works'
         }
-        cap { 'c':
-          message => 'c works'
-        }
       MANIFEST
       expect(catalog.resource(:test1, "a")['message']).to eq('a works')
       expect(catalog.resource(:test2, "b")['message']).to eq('b works')
       expect(catalog.resource(:test3, "x/y")['message']).to eq('x/y works')
-      expect(catalog.resource(:cap, "c")['message']).to eq('c works')
-    end
-
-    it 'considers Pcore types to be builtin ' do
-      genface.types
-      catalog = compile_to_catalog(<<-MANIFEST)
-        test1 { 'a':
-          message => 'a works'
-        }
-      MANIFEST
-      expect(catalog.resource(:test1, "a").kind).to eq('compilable_type')
     end
 
     it 'the validity of attribute names are checked' do
@@ -168,20 +144,6 @@ describe 'when pcore described resources types are in use' do
       expect(catalog.resource(:test1, "a")['noop']).to eq(true)
     end
 
-    it 'capability is propagated to the catalog' do
-      genface.types
-      catalog = compile_to_catalog(<<-MANIFEST)
-        test2 { 'r':
-          message => 'a resource'
-        }
-        cap { 'c':
-          message => 'a cap'
-        }
-      MANIFEST
-      expect(catalog.resource(:test2, "r").is_capability?).to eq(false)
-      expect(catalog.resource(:cap, "c").is_capability?).to eq(true)
-    end
-
     it 'a generated type describes if it is isomorphic' do
       generate_and_in_a_compilers_context do |compiler|
         t1 = find_resource_type(compiler.topscope, 'test1')
@@ -191,15 +153,6 @@ describe 'when pcore described resources types are in use' do
       end
     end
 
-    it 'a generated type describes if it is a capability' do
-      generate_and_in_a_compilers_context do |compiler|
-        t1 = find_resource_type(compiler.topscope, 'test1')
-        expect(t1.is_capability?).to be(false)
-        t2 = find_resource_type(compiler.topscope, 'cap')
-        expect(t2.is_capability?).to be(true)
-      end
-    end
-
     it 'a generated type returns parameters defined in pcore' do
       generate_and_in_a_compilers_context do |compiler|
         t1 = find_resource_type(compiler.topscope, 'test1')

data/spec/integration/resource/type_collection_spec.rb

@@ -11,8 +11,12 @@ describe Puppet::Resource::TypeCollection do
       @dir = tmpfile("autoload_testing")
       FileUtils.mkdir_p @dir
 
-      loader = double('loader', load: nil, set_entry: nil)
-      loaders = double('loaders', runtime3_type_loader: loader)
+      loader = Object.new
+      allow(loader).to receive(:load).and_return(nil)
+      allow(loader).to receive(:set_entry)
+
+      loaders = Object.new
+      expect(loaders).to receive(:runtime3_type_loader).at_most(:once).and_return(loader)
       expect(Puppet::Pops::Loaders).to receive(:loaders).at_most(:once).and_return(loaders)
 
       environment = Puppet::Node::Environment.create(:env, [@dir])