puppet 6.23.0 → 6.26.0

data/spec/unit/http/service/compiler_spec.rb

@@ -96,6 +96,14 @@ describe Puppet::HTTP::Service::Compiler do
       subject.post_catalog(certname, environment: 'production', facts: facts, configured_environment: 'agent_specified')
     end
 
+    it 'includes check_environment' do
+      stub_request(:post, uri)
+        .with(body: hash_including('check_environment' => 'false'))
+        .to_return(**catalog_response)
+
+      subject.post_catalog(certname, environment: 'production', facts: facts)
+    end
+
     it 'includes transaction_uuid' do
       uuid = "ec3d2844-b236-4287-b0ad-632fbb4d1ff0"
 

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -11,6 +11,9 @@ def set_facts(fact_hash)
 end
 
 describe Puppet::Resource::Catalog::Compiler do
+  include Matchers::Resource
+  include PuppetSpec::Files
+
   let(:compiler) { described_class.new }
   let(:node_name) { "foo" }
   let(:node) { Puppet::Node.new(node_name)}
@@ -236,6 +239,46 @@ describe Puppet::Resource::Catalog::Compiler do
       expect { compiler.find(@request) }.to raise_error Puppet::Error,
         "Unable to find a common checksum type between agent '' and master '[:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :sha512, :sha384, :sha224, :mtime, :ctime, :none]'."
     end
+
+    it "prevents the environment from being evicted during compilation" do
+      Puppet[:environment_timeout] = 0
+
+      envs = Puppet.lookup(:environments)
+
+      expect(compiler).to receive(:compile) do
+        # we should get the same object
+        expect(envs.get!(:production)).to equal(envs.get!(:production))
+      end
+
+      compiler.find(@request)
+    end
+
+    context 'when checking agent and server specified environments' do
+      before :each do
+        FileUtils.mkdir_p(File.join(Puppet[:environmentpath], 'env_server'))
+        FileUtils.mkdir_p(File.join(Puppet[:environmentpath], 'env_agent'))
+
+        node.environment = 'env_server'
+        allow(Puppet::Node.indirection).to receive(:find).and_return(node)
+
+        @request.environment = 'env_agent'
+      end
+
+      it 'ignores mismatched environments by default' do
+        catalog = compiler.find(@request)
+
+        expect(catalog.environment).to eq('env_server')
+        expect(catalog).to have_resource('Stage[main]')
+      end
+
+      it 'returns an empty catalog if asked to check the environment and they are mismatched' do
+        @request.options[:check_environment] = "true"
+        catalog = compiler.find(@request)
+
+        expect(catalog.environment).to eq('env_server')
+        expect(catalog.resources).to be_empty
+      end
+    end
   end
 
   describe "when handling a request with facts" do
@@ -564,6 +607,50 @@ describe Puppet::Resource::Catalog::Compiler do
       metadata
     end
 
+    describe "and the environment is a symlink and versioned_environment_dirs is true" do
+
+      let(:tmpdir) { Dir.mktmpdir }
+
+      before(:each) do
+        Puppet[:versioned_environment_dirs] = true
+        prod_path = File.join(Puppet[:environmentpath], 'production')
+        FileUtils.rm_rf(prod_path)
+        FileUtils.symlink(tmpdir, prod_path)
+      end
+
+      it "inlines metadata for a file" do
+        catalog = compile_to_catalog(<<-MANIFEST, node)
+        file { '#{path}':
+          ensure => file,
+          source => '#{source}'
+        }
+      MANIFEST
+
+        module_relative_path = 'modules/mymodule/files/config_file.txt'
+        metadata = stubs_file_metadata(checksum_type,
+                                       checksum_value,
+                                       module_relative_path,
+                                       File.join(tmpdir, module_relative_path) )
+        expect(metadata).to receive(:source=).with(source)
+        expect(metadata).to receive(:content_uri=).with("puppet:///#{module_relative_path}")
+
+        options = {
+          :environment => catalog.environment_instance,
+          :links => :manage,
+          :checksum_type => checksum_type.to_sym,
+          :source_permissions => :ignore
+        }
+        expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, options).and_return(metadata)
+
+        compiler.send(:inline_metadata, catalog, checksum_type)
+
+
+        expect(catalog.metadata[path]).to eq(metadata)
+        expect(catalog.recursive_metadata).to be_empty
+
+      end
+    end
+
     it "inlines metadata for a file" do
       catalog = compile_to_catalog(<<-MANIFEST, node)
         file { '#{path}':

data/spec/unit/indirector/catalog/rest_spec.rb

@@ -33,6 +33,14 @@ describe Puppet::Resource::Catalog::Rest do
     described_class.indirection.find(certname, environment: Puppet::Node::Environment.remote('outerspace'))
   end
 
+  it "passes 'check_environment'" do
+    stub_request(:post, uri)
+      .with(body: hash_including('check_environment' => 'true'))
+      .to_return(**catalog_response(catalog))
+
+    described_class.indirection.find(certname, check_environment: true)
+  end
+
   it 'constructs a catalog environment_instance' do
     env = Puppet::Node::Environment.remote('outerspace')
     catalog = Puppet::Resource::Catalog.new(certname, env)

data/spec/unit/indirector/indirection_spec.rb

@@ -499,7 +499,7 @@ describe Puppet::Indirector::Indirection do
         end
 
         it "should return the result of saving to the terminus" do
-          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false)
+          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false, :ignore_terminus? => false)
 
           expect(@indirection).to receive(:request).and_return(request)
 
@@ -509,7 +509,7 @@ describe Puppet::Indirector::Indirection do
         end
 
         it "should use a request to save the object to the cache" do
-          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false)
+          request = double('request', :instance => @instance, :node => nil, :ignore_cache_save? => false, :ignore_terminus? => false)
 
           expect(@indirection).to receive(:request).and_return(request)
 
@@ -519,7 +519,7 @@ describe Puppet::Indirector::Indirection do
         end
 
         it "should not save to the cache if the normal save fails" do
-          request = double('request', :instance => @instance, :node => nil)
+          request = double('request', :instance => @instance, :node => nil, :ignore_terminus? => false)
 
           expect(@indirection).to receive(:request).and_return(request)
 
@@ -534,6 +534,13 @@ describe Puppet::Indirector::Indirection do
 
           @indirection.save(@instance, '/my/key', :ignore_cache_save => true)
         end
+
+        it "should only save to the cache if the request specifies not to use the terminus" do
+          expect(@terminus).not_to receive(:save)
+          expect(@cache).to receive(:save)
+
+          @indirection.save(@instance, "/my/key", :ignore_terminus => true)
+        end
       end
     end
 

data/spec/unit/indirector/resource/ral_spec.rb

@@ -1,120 +1,85 @@
 require 'spec_helper'
 require 'puppet/indirector/resource/ral'
 
-describe "Puppet::Resource::Ral" do
+describe Puppet::Resource::Ral do
+  let(:my_instance) { Puppet::Type.type(:user).new(:name => "root") }
+  let(:wrong_instance) { Puppet::Type.type(:user).new(:name => "bob")}
+
+  def stub_retrieve(*instances)
+    instances.each do |i|
+      allow(i).to receive(:retrieve).and_return(Puppet::Resource.new(i, nil))
+    end
+  end
+
+  before do
+    described_class.indirection.terminus_class = :ral
+
+    # make sure we don't try to retrieve current state
+    allow_any_instance_of(Puppet::Type.type(:user)).to receive(:retrieve).never
+    stub_retrieve(my_instance, wrong_instance)
+  end
+
   it "disallows remote requests" do
     expect(Puppet::Resource::Ral.new.allow_remote_requests?).to eq(false)
   end
 
   describe "find" do
-    before do
-      @request = double('request', :key => "user/root")
-    end
-
     it "should find an existing instance" do
-      my_resource    = double("my user resource")
+      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ wrong_instance, my_instance, wrong_instance ])
 
-      wrong_instance = double("wrong user", :name => "bob")
-      my_instance    = double("my user",    :name => "root", :to_resource => my_resource)
-
-      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ wrong_instance, my_instance, wrong_instance ])
-      expect(Puppet::Resource::Ral.new.find(@request)).to eq(my_resource)
+      actual_resource = described_class.indirection.find('user/root')
+      expect(actual_resource.name).to eq('User/root')
     end
 
     it "should produce Puppet::Error instead of ArgumentError" do
-      @bad_request = double('thiswillcauseanerror', :key => "thiswill/causeanerror")
-      expect{Puppet::Resource::Ral.new.find(@bad_request)}.to raise_error(Puppet::Error)
+      expect{described_class.indirection.find('thiswill/causeanerror')}.to raise_error(Puppet::Error)
     end
 
     it "if there is no instance, it should create one" do
-      wrong_instance = double("wrong user", :name => "bob")
-      root = double("Root User")
-      root_resource = double("Root Resource")
-
-      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ wrong_instance, wrong_instance ])
-      expect(Puppet::Type.type(:user)).to receive(:new).with(hash_including(name: "root")).and_return(root)
-      expect(root).to receive(:to_resource).and_return(root_resource)
-
-      result = Puppet::Resource::Ral.new.find(@request)
+      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([wrong_instance])
 
-      expect(result).to eq(root_resource)
+      expect(Puppet::Type.type(:user)).to receive(:new).with(hash_including(name: "root")).and_return(my_instance)
+      expect(described_class.indirection.find('user/root')).to be
     end
   end
 
   describe "search" do
-    before do
-      @request = double('request', :key => "user/", :options => {})
-    end
-
     it "should convert ral resources into regular resources" do
-      my_resource = double("my user resource", :title => "my user resource")
-      my_instance = double("my user", :name => "root", :to_resource => my_resource)
+      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance ])
 
-      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance ])
-      expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
+      actual = described_class.indirection.search('user')
+      expect(actual).to contain_exactly(an_instance_of(Puppet::Resource))
     end
 
     it "should filter results by name if there's a name in the key" do
-      my_resource = double("my user resource", title: "my user resource")
-      allow(my_resource).to receive(:to_resource).and_return(my_resource)
-      allow(my_resource).to receive(:[]).with(:name).and_return("root")
-
-      wrong_resource = double("wrong resource")
-      allow(wrong_resource).to receive(:to_resource).and_return(wrong_resource)
-      allow(wrong_resource).to receive(:[]).with(:name).and_return("bad")
+      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance, wrong_instance ])
 
-      my_instance    = double("my user",    :to_resource => my_resource)
-      wrong_instance = double("wrong user", :to_resource => wrong_resource)
-
-      @request = double('request', :key => "user/root", :options => {})
-
-      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance, wrong_instance ])
-      expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
+      actual = described_class.indirection.search('user/root')
+      expect(actual).to contain_exactly(an_object_having_attributes(name: 'User/root'))
     end
 
     it "should filter results by query parameters" do
-      wrong_resource = double("my user resource", title: "my user resource")
-      allow(wrong_resource).to receive(:to_resource).and_return(wrong_resource)
-      allow(wrong_resource).to receive(:[]).with(:name).and_return("root")
-
-      my_resource = double("wrong resource", title: "wrong resource")
-      allow(my_resource).to receive(:to_resource).and_return(my_resource)
-      allow(my_resource).to receive(:[]).with(:name).and_return("bob")
+      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance, wrong_instance ])
 
-      my_instance    = double("my user",    :to_resource => my_resource)
-      wrong_instance = double("wrong user", :to_resource => wrong_resource)
-
-      @request = double('request', :key => "user/", :options => {:name => "bob"})
-
-      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance, wrong_instance ])
-      expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
+      actual = described_class.indirection.search('user', name: 'bob')
+      expect(actual).to contain_exactly(an_object_having_attributes(name: 'User/bob'))
     end
 
     it "should return sorted results" do
-      a_resource = double("alice resource")
-      allow(a_resource).to receive(:to_resource).and_return(a_resource)
-      allow(a_resource).to receive(:title).and_return("alice")
-
-      b_resource = double("bob resource")
-      allow(b_resource).to receive(:to_resource).and_return(b_resource)
-      allow(b_resource).to receive(:title).and_return("bob")
-
-      a_instance = double("alice user", :to_resource => a_resource)
-      b_instance = double("bob user",   :to_resource => b_resource)
-
-      @request = double('request', :key => "user/", :options => {})
+      a_instance = Puppet::Type.type(:user).new(:name => "alice")
+      b_instance = Puppet::Type.type(:user).new(:name => "bob")
+      stub_retrieve(a_instance, b_instance)
+      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ b_instance, a_instance ])
 
-      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ b_instance, a_instance ])
-      expect(Puppet::Resource::Ral.new.search(@request)).to eq([a_resource, b_resource])
+      expect(described_class.indirection.search('user').map(&:title)).to eq(['alice', 'bob'])
     end
   end
 
   describe "save" do
     it "returns a report covering the application of the given resource to the system" do
       resource = Puppet::Resource.new(:notify, "the title")
-      ral = Puppet::Resource::Ral.new
 
-      applied_resource, report = ral.save(Puppet::Indirector::Request.new(:ral, :save, 'testing', resource, :environment => Puppet::Node::Environment.remote(:testing)))
+      applied_resource, report = described_class.indirection.save(resource, nil, environment: Puppet::Node::Environment.remote(:testing))
 
       expect(applied_resource.title).to eq("the title")
       expect(report.environment).to eq("testing")

data/spec/unit/interface/action_spec.rb

@@ -537,15 +537,6 @@ describe Puppet::Interface::Action do
     end
   end
 
-  context "#when_rendering" do
-    it "should fail if no type is given when_rendering"
-    it "should accept a when_rendering block"
-    it "should accept multiple when_rendering blocks"
-    it "should fail if when_rendering gets a non-symbol identifier"
-    it "should fail if a second block is given for the same type"
-    it "should return the block if asked"
-  end
-
   context "#validate_and_clean" do
     subject do
       Puppet::Interface.new(:validate_args, '1.0.0') do

data/spec/unit/module_spec.rb

@@ -478,7 +478,7 @@ describe Puppet::Module do
     end
   end
 
-  [:plugins, :pluginfacts, :templates, :files, :manifests].each do |filetype|
+  [:plugins, :pluginfacts, :templates, :files, :manifests, :scripts].each do |filetype|
     case filetype
       when :plugins
         dirname = "lib"
@@ -567,6 +567,20 @@ describe Puppet::Module do
       expect(mod.task_file(task_exe)).to eq("#{mod.path}/tasks/#{task_exe}")
     end
 
+    it "should list files from the scripts directory if required by the task" do
+      mod         = 'loads_scripts'
+      task_dep    = 'myscript.sh'
+      script_ref  = "#{mod}/scripts/#{task_dep}"
+      task_json   = JSON.generate({'files' => [script_ref]})
+      task        = [['task', { name: 'task.json', content: task_json }]]
+      mod         = PuppetSpec::Modules.create(mod, @modpath, {:environment => env,
+                                                       :scripts     => [task_dep],
+                                                       :tasks       => task})
+
+      expect(mod.tasks.first.files).to include({'name' => script_ref,
+                                                'path' => /#{script_ref}/})
+    end
+
     it "should return nil when asked for an individual task file if it does not exist" do
       mod = PuppetSpec::Modules.create('task_file_neg', @modpath, {:environment => env,
                                                                    :tasks => []})

data/spec/unit/module_tool/applications/installer_spec.rb

@@ -66,6 +66,18 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => RUBY_PLATFORM =
       graph_should_include 'pmtacceptance-stdlib', nil => v('4.1.0')
     end
 
+    it 'reports a meaningful error if the name is invalid' do
+      app = installer('ntp', install_dir, options)
+      results = app.run
+      expect(results).to include :result => :failure
+      expect(results[:error][:oneline]).to eq("Could not install 'ntp', did you mean 'puppetlabs-ntp'?")
+      expect(results[:error][:multiline]).to eq(<<~END.chomp)
+        Could not install module 'ntp'
+          The name 'ntp' is invalid
+            Did you mean `puppet module install puppetlabs-ntp`?
+      END
+    end
+
     context 'with a tarball file' do
       let(:module) { fixtures('stdlib.tgz') }
 
@@ -273,18 +285,45 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => RUBY_PLATFORM =
           expect(subject).to include :result => :failure
         end
 
-        it 'prints a detailed error containing the modules that would not be satisfied' do
-          graph = double(SemanticPuppet::Dependency::Graph, :modules => ['pmtacceptance-mysql'])
-          exception = SemanticPuppet::Dependency::UnsatisfiableGraph.new(graph)
-          allow(exception).to receive(:respond_to?).and_return(true)
-          allow(exception).to receive(:unsatisfied).and_return('pmtacceptance-mysql')
-          allow(SemanticPuppet::Dependency).to receive(:resolve).and_raise(exception)
-
-          expect(subject[:error]).to include(:multiline)
-          expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (> 1.0.0)")
-          expect(subject[:error][:multiline]).to include("The requested version cannot satisfy one or more of the following installed modules:")
-          expect(subject[:error][:multiline]).to include("pmtacceptance-keystone, expects 'pmtacceptance-mysql': >=0.6.1 <1.0.0")
-          expect(subject[:error][:multiline]).to include("Use `puppet module install 'pmtacceptance-mysql' --ignore-dependencies` to install only this module")
+        context 'with unsatisfiable dependencies' do
+          let(:graph) { double(SemanticPuppet::Dependency::Graph, :modules => ['pmtacceptance-mysql']) }
+          let(:exception) { SemanticPuppet::Dependency::UnsatisfiableGraph.new(graph, constraint) }
+
+          before do
+            allow(SemanticPuppet::Dependency).to receive(:resolve).and_raise(exception)
+          end
+
+          context 'with known constraint' do
+            let(:constraint) { 'pmtacceptance-mysql' }
+
+            it 'prints a detailed error containing the modules that would not be satisfied' do
+              expect(subject[:error]).to include(:multiline)
+              expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (> 1.0.0)")
+              expect(subject[:error][:multiline]).to include("The requested version cannot satisfy one or more of the following installed modules:")
+              expect(subject[:error][:multiline]).to include("pmtacceptance-keystone, expects 'pmtacceptance-mysql': >=0.6.1 <1.0.0")
+              expect(subject[:error][:multiline]).to include("Use `puppet module install 'pmtacceptance-mysql' --ignore-dependencies` to install only this module")
+            end
+          end
+
+          context 'with missing constraint' do
+            let(:constraint) { nil }
+
+            it 'prints the generic error message' do
+              expect(subject[:error]).to include(:multiline)
+              expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (> 1.0.0)")
+              expect(subject[:error][:multiline]).to include("The requested version cannot satisfy all dependencies")
+            end
+          end
+
+          context 'with unknown constraint' do
+            let(:constraint) { 'another' }
+
+            it 'prints the generic error message' do
+              expect(subject[:error]).to include(:multiline)
+              expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (> 1.0.0)")
+              expect(subject[:error][:multiline]).to include("The requested version cannot satisfy all dependencies")
+            end
+          end
         end
 
         context 'with --ignore-dependencies' do

data/spec/unit/network/authstore_spec.rb

@@ -101,21 +101,6 @@ describe Puppet::Network::AuthStore::Declaration do
     }
   }
 
-  describe "when the pattern is a numeric IP with a back reference" do
-    pending("implementation of backreferences for IP") do
-      before :each do
-        @ip = '100.101.$1'
-        @declaration = Puppet::Network::AuthStore::Declaration.new(:allow_ip,@ip).interpolate('12.34'.match(/(.*)/))
-      end
-      it "should match an IP with the appropriate interpolation" do
-        @declaration.should be_match('www.testsite.org',@ip.sub(/\$1/,'12.34'))
-      end
-      it "should not match other IPs" do
-        @declaration.should_not be_match('www.testsite.org',@ip.sub(/\$1/,'66.34'))
-      end
-    end
-  end
-
   [
     "02001:0000:1234:0000:0000:C1C0:ABCD:0876",
     "2001:0000:1234:0000:00001:C1C0:ABCD:0876",

data/spec/unit/network/formats_spec.rb

@@ -368,6 +368,12 @@ describe "Puppet Network Format" do
       expect(json.render_multiple(instances)).to eq([{"string" => "foo"}].to_json)
     end
 
+    it "should render multiple instances as a JSON array of hashes when multi_json is not present" do
+      hide_const("MultiJson") if defined?(MultiJson)
+      instances = [FormatsTest.new("foo")]
+      expect(json.render_multiple(instances)).to eq([{"string" => "foo"}].to_json)
+    end
+
     it "should intern an instance from a JSON hash" do
       text = Puppet::Util::Json.dump({"string" => "parsed_json"})
       instance = json.intern(FormatsTest, text)

data/spec/unit/node_spec.rb

@@ -40,6 +40,12 @@ describe Puppet::Node do
         expect(node.environment.name).to eq(:bar)
       end
 
+      it "sets environment_name with the correct environment name" do
+        node = Puppet::Node.new("foo")
+        node.environment = Puppet::Node::Environment.remote('www123')
+        expect(node.environment_name).to eq(:www123)
+      end
+
       it "allows its environment to be set by parameters after initialization" do
         node = Puppet::Node.new("foo")
         node.parameters["environment"] = :bar

data/spec/unit/parser/templatewrapper_spec.rb

@@ -2,6 +2,8 @@ require 'spec_helper'
 require 'puppet/parser/templatewrapper'
 
 describe Puppet::Parser::TemplateWrapper do
+  include PuppetSpec::Files
+
   let(:known_resource_types) { Puppet::Resource::TypeCollection.new("env") }
   let(:scope) do
     compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
@@ -41,6 +43,13 @@ describe Puppet::Parser::TemplateWrapper do
     expect(tw.result).to eq(full_file_name)
   end
 
+  it "ignores a leading BOM" do
+    full_file_name = given_a_template_file("bom_template", "\uFEFF<%= file %>")
+
+    tw.file = "bom_template"
+    expect(tw.result).to eq(full_file_name)
+  end
+
   it "evaluates a given string as a template" do
     expect(tw.result("template contents")).to eql("template contents")
   end
@@ -90,11 +99,12 @@ describe Puppet::Parser::TemplateWrapper do
   end
 
   def given_a_template_file(name, contents)
-    full_name = "/full/path/to/#{name}"
+    full_name = tmpfile("template_#{name}")
+    File.binwrite(full_name, contents)
+
     allow(Puppet::Parser::Files).to receive(:find_template).
       with(name, anything()).
       and_return(full_name)
-    allow(Puppet::FileSystem).to receive(:read_preserve_line_endings).with(full_name).and_return(contents)
 
     full_name
   end

data/spec/unit/pops/parser/parse_containers_spec.rb

@@ -95,18 +95,7 @@ describe "egrammar parsing containers" do
         expect(dump(parse("class foo::default {}"))).to eq("(class foo::default ())")
       end
 
-      it "class class inherits default {} # inherits default", :broken => true do
-        expect {
-          parse("class class inherits default {}")
-        }.to raise_error(/not a valid classname/)
-      end
-
       it "class class inherits default {} # inherits default" do
-        # TODO: See previous test marked as :broken=>true, it is actually this test (result) that is wacky,
-        # this because a class is named at parse time (since class evaluation is lazy, the model must have the
-        # full class name for nested classes - only, it gets this wrong when a class is named "class" - or at least
-        # I think it is wrong.)
-        #
         expect { parse("class class inherits default {}") }.to raise_error(/'class' keyword not allowed at this location/)
       end
 
@@ -117,7 +106,7 @@ describe "egrammar parsing containers" do
 
     context 'it should allow keywords as attribute names' do
       ['and', 'case', 'class', 'default', 'define', 'else', 'elsif', 'if', 'in', 'inherits', 'node', 'or',
-        'undef', 'unless', 'type', 'attr', 'function', 'private'].each do |keyword|
+        'undef', 'unless', 'type', 'attr', 'function', 'private', 'plan', 'apply'].each do |keyword|
         it "such as #{keyword}" do
           expect { parse("class x ($#{keyword}){} class { x: #{keyword} => 1 }") }.to_not raise_error
         end
@@ -189,7 +178,7 @@ describe "egrammar parsing containers" do
 
     context 'it should allow keywords as attribute names' do
       ['and', 'case', 'class', 'default', 'define', 'else', 'elsif', 'if', 'in', 'inherits', 'node', 'or',
-        'undef', 'unless', 'type', 'attr', 'function', 'private'].each do |keyword|
+        'undef', 'unless', 'type', 'attr', 'function', 'private', 'plan', 'apply'].each do |keyword|
         it "such as #{keyword}" do
           expect {parse("define x ($#{keyword}){} x { y: #{keyword} => 1 }")}.to_not raise_error
         end

data/spec/unit/pops/serialization/to_stringified_spec.rb

@@ -154,4 +154,9 @@ describe 'ToStringifiedConverter' do
     unassigned = [243, 176, 128, 128].pack("C*").force_encoding(Encoding::UTF_8) 
     expect(transform(unassigned)).to eq("󰀀")
   end
+
+  it 'converts ProcessOutput objects to string' do
+    object = Puppet::Util::Execution::ProcessOutput.new('object', 0)
+    expect(transform(object)).to be_instance_of(String)
+  end
 end

data/spec/unit/pops/types/type_calculator_spec.rb

@@ -1980,6 +1980,12 @@ describe 'The type calculator' do
       expect(calculator.instance?(tuple, [1, 'a', 1])).to          eq(false)
     end
 
+    it 'should not consider ProcessOutput objects as instanceof PScalarDataType' do
+      object = Puppet::Util::Execution::ProcessOutput.new('object', 0)
+      
+      expect(calculator.instance?(PScalarDataType::DEFAULT, object)).to eq(false)
+    end
+
     context 'and t is Struct' do
       it 'should consider hash[cont] as instance of Struct[cont-t]' do
         struct = struct_t({'a'=>Integer, 'b'=>String, 'c'=>Float})

data/spec/unit/pops/validator/validator_spec.rb

@@ -432,6 +432,11 @@ describe "validating 4x" do
         expect(acceptor.error_count).to eql(0)
       end
 
+      it 'allows apply to be used as a resource attribute name' do
+        acceptor = validate(parse('apply("foo.example.com") { sometype { "resourcetitle": apply => "applyvalue" } }'))
+        expect(acceptor.error_count).to eql(0)
+      end
+
       it 'accepts multiple arguments' do
         acceptor = validate(parse('apply(["foo.example.com"], { "other" => "args" }) { }'))
         expect(acceptor.error_count).to eql(0)

data/spec/unit/provider/package/gem_spec.rb

@@ -442,7 +442,7 @@ context Puppet::Type.type(:package).provider(:gem) do
     end
 
     context 'when is defaultfor' do
-      let(:os) {  Facter.value(:operatingsystem) }
+      let(:os) {  Puppet.runtime[:facter].value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

data/spec/unit/provider/package/pip2_spec.rb

@@ -24,7 +24,7 @@ describe Puppet::Type.type(:package).provider(:pip2) do
     end
 
     context 'when is defaultfor' do
-      let(:os) {  Facter.value(:operatingsystem) }
+      let(:os) {  Puppet.runtime[:facter].value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity