puppet 4.4.2 → 4.5.0

data/spec/integration/parser/resource_expressions_spec.rb

@@ -114,7 +114,7 @@ describe "Puppet resource expressions" do
 
     fails( "define a::b { notify { testing: } } 'a::b' { title: }" => /Illegal Resource Type expression.*got String/)
 
-    fails( "Does::Not::Exist { title: }" => /Invalid resource type does::not::exist/)
+    fails( "Does::Not::Exist { title: }" => /Resource type not found: Does::Not::Exist/)
   end
 
   context "local defaults" do

data/spec/integration/resource/type_collection_spec.rb

@@ -12,6 +12,14 @@ describe Puppet::Resource::TypeCollection do
       @dir = tmpfile("autoload_testing")
       FileUtils.mkdir_p @dir
 
+      loader = Object.new
+      loader.stubs(:load).returns nil
+      loader.stubs(:set_entry)
+
+      loaders = Object.new
+      loaders.expects(:runtime3_type_loader).at_most_once.returns loader
+      Puppet::Pops::Loaders.expects(:loaders).at_most_once.returns loaders
+
       environment = Puppet::Node::Environment.create(:env, [@dir])
       @code = environment.known_resource_types
     end

data/spec/lib/puppet_spec/compiler.rb

@@ -1,14 +1,14 @@
 module PuppetSpec::Compiler
   module_function
 
-  def compile_to_catalog(string, node = Puppet::Node.new('foonode'))
+  def compile_to_catalog(string, node = Puppet::Node.new('test'))
     Puppet[:code] = string
     # see lib/puppet/indirector/catalog/compiler.rb#filter
     Puppet::Parser::Compiler.compile(node).filter { |r| r.virtual? }
   end
 
-  def compile_to_ral(manifest)
-    catalog = compile_to_catalog(manifest)
+  def compile_to_ral(manifest, node = Puppet::Node.new('test'))
+    catalog = compile_to_catalog(manifest, node)
     ral = catalog.to_ral
     ral.finalize
     ral
@@ -60,7 +60,14 @@ module PuppetSpec::Compiler
 
   def eval_and_collect_notices(code, node = Puppet::Node.new('foonode'))
     collect_notices(code, node) do |compiler|
-      compiler.compile
+      if block_given?
+        compiler.compile do |catalog|
+          yield(compiler.topscope, catalog)
+          catalog
+        end
+      else
+        compiler.compile
+      end
     end
   end
 end

data/spec/shared_contexts/types_setup.rb

@@ -32,6 +32,8 @@ shared_context 'types_setup' do
       Puppet::Pops::Types::PDefaultType,
       Puppet::Pops::Types::PTypeReferenceType,
       Puppet::Pops::Types::PTypeAliasType,
+      Puppet::Pops::Types::PSemVerType,
+      Puppet::Pops::Types::PSemVerRangeType,
     ]
   end
 
@@ -47,6 +49,8 @@ shared_context 'types_setup' do
       Puppet::Pops::Types::PBooleanType,
       Puppet::Pops::Types::PPatternType,
       Puppet::Pops::Types::PEnumType,
+      Puppet::Pops::Types::PSemVerType,
+      Puppet::Pops::Types::PSemVerRangeType,
     ]
   end
 

data/spec/unit/application/lookup_spec.rb

@@ -166,7 +166,8 @@ describe Puppet::Application::Lookup do
       lookup.options[:node] = node
       lookup.options[:explain] = true
       lookup.command_line.stubs(:args).returns(['a'])
-      expect { lookup.run_command }.to output(<<-EXPLANATION).to_stdout
+      begin
+        expect { lookup.run_command }.to output(<<-EXPLANATION).to_stdout
 Merge strategy first
   Data Binding "hiera"
     No such key: "a"
@@ -177,13 +178,17 @@ Merge strategy first
         Original path: "common"
         Found key: "a" value: "This is A"
   Merged result: "This is A"
-      EXPLANATION
+        EXPLANATION
+      rescue SystemExit => e
+        expect(e.status).to eq(0)
+      end
     end
 
     it '--explain produces human readable text of a hash merge when using --explain-options' do
       lookup.options[:node] = node
       lookup.options[:explain_options] = true
-      expect { lookup.run_command }.to output(<<-EXPLANATION).to_stdout
+      begin
+        expect { lookup.run_command }.to output(<<-EXPLANATION).to_stdout
 Merge strategy hash
   Data Binding "hiera"
     No such key: "lookup_options"
@@ -198,7 +203,10 @@ Merge strategy hash
   Merged result: {
     "a" => "first"
   }
-      EXPLANATION
+        EXPLANATION
+      rescue SystemExit => e
+        expect(e.status).to eq(0)
+      end
     end
 
     it '--explain produces human readable text of a hash merge when using both --explain and --explain-options' do
@@ -206,7 +214,8 @@ Merge strategy hash
       lookup.options[:explain] = true
       lookup.options[:explain_options] = true
       lookup.command_line.stubs(:args).returns(['a'])
-      expect { lookup.run_command }.to output(<<-EXPLANATION).to_stdout
+      begin
+        expect { lookup.run_command }.to output(<<-EXPLANATION).to_stdout
 Searching for "lookup_options"
   Merge strategy hash
     Data Binding "hiera"
@@ -233,7 +242,10 @@ Searching for "a"
           Original path: "common"
           Found key: "a" value: "This is A"
     Merged result: "This is A"
-      EXPLANATION
+        EXPLANATION
+      rescue SystemExit => e
+        expect(e.status).to eq(0)
+      end
     end
 
     it 'can produce a yaml explanation' do
@@ -247,6 +259,8 @@ Searching for "a"
         $stdout = StringIO.new
         lookup.run_command
         output = $stdout.string
+      rescue SystemExit => e
+        expect(e.status).to eq(0)
       ensure
         $stdout = save_stdout
       end
@@ -264,12 +278,68 @@ Searching for "a"
         $stdout = StringIO.new
         lookup.run_command
         output = $stdout.string
+      rescue SystemExit => e
+        expect(e.status).to eq(0)
       ensure
         $stdout = save_stdout
       end
       expect(JSON.parse(output)).to eq(expected_json_hash)
     end
 
+    it 'can access values using dotted keys' do
+      lookup.options[:node] = node
+      lookup.options[:render_as] = :json
+      lookup.command_line.stubs(:args).returns(['d.one.two.three'])
+      save_stdout = $stdout
+      output = nil
+      begin
+        $stdout = StringIO.new
+        lookup.run_command
+        output = $stdout.string
+      rescue SystemExit => e
+        expect(e.status).to eq(0)
+      ensure
+        $stdout = save_stdout
+      end
+      expect(JSON.parse("[#{output}]")).to eq(['the value'])
+    end
+
+    it 'can access values using quoted dotted keys' do
+      lookup.options[:node] = node
+      lookup.options[:render_as] = :json
+      lookup.command_line.stubs(:args).returns(['"e.one.two.three"'])
+      save_stdout = $stdout
+      output = nil
+      begin
+        $stdout = StringIO.new
+        lookup.run_command
+        output = $stdout.string
+      rescue SystemExit => e
+        expect(e.status).to eq(0)
+      ensure
+        $stdout = save_stdout
+      end
+      expect(JSON.parse("[#{output}]")).to eq(['the value'])
+    end
+
+    it 'can access values using mix of dotted keys and quoted dotted keys' do
+      lookup.options[:node] = node
+      lookup.options[:render_as] = :json
+      lookup.command_line.stubs(:args).returns(['"f.one"."two.three".1'])
+      save_stdout = $stdout
+      output = nil
+      begin
+        $stdout = StringIO.new
+        lookup.run_command
+        output = $stdout.string
+      rescue SystemExit => e
+        expect(e.status).to eq(0)
+      ensure
+        $stdout = save_stdout
+      end
+      expect(JSON.parse("[#{output}]")).to eq(['second value'])
+    end
+
     context 'the global scope' do
       it "is unaffected by global variables unless '--compile' is used" do
         lookup.options[:node] = node
@@ -281,7 +351,11 @@ Searching for "a"
         lookup.options[:node] = node
         lookup.options[:compile] = true
         lookup.command_line.stubs(:args).returns(['c'])
-        expect { lookup.run_command }.to output("--- This is C from site.pp\n...\n").to_stdout
+        begin
+          expect { lookup.run_command }.to output("--- This is C from site.pp\n...\n").to_stdout
+        rescue SystemExit => e
+          expect(e.status).to eq(0)
+        end
       end
     end
 
@@ -291,14 +365,22 @@ Searching for "a"
       it "works OK in the absense of '--compile'" do
         lookup.options[:node] = node
         lookup.command_line.stubs(:args).returns(['c'])
-        expect { lookup.run_command }.to output("--- This is C from data.pp\n...\n").to_stdout
+        begin
+          expect { lookup.run_command }.to output("--- This is C from data.pp\n...\n").to_stdout
+        rescue SystemExit => e
+          expect(e.status).to eq(0)
+        end
       end
 
       it "global scope is affected by global variables when '--compile' is used" do
         lookup.options[:node] = node
         lookup.options[:compile] = true
         lookup.command_line.stubs(:args).returns(['c'])
-        expect { lookup.run_command }.to output("--- This is C from site.pp\n...\n").to_stdout
+        begin
+          expect { lookup.run_command }.to output("--- This is C from site.pp\n...\n").to_stdout
+        rescue SystemExit => e
+          expect(e.status).to eq(0)
+        end
       end
     end
   end

data/spec/unit/appmgmt_spec.rb

@@ -1,34 +1,33 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
-require_relative 'pops/parser/parser_rspec_helper'
 require 'puppet/parser/environment_compiler'
 
 describe "Application instantiation" do
   include PuppetSpec::Compiler
-  # We pull this in because we need access to with_app_management; and
-  # since that has to root around in the guts of the Pops parser, there's
-  # no really elegant way to do this
-  include ParserRspecHelper
 
-  def compile_to_env_catalog(string)
+  let(:env) { Puppet::Node::Environment.create(:testing, []) }
+  let(:node) { Puppet::Node.new('test', :environment => env) }
+  let(:loaders) { Puppet::Pops::Loaders.new(env) }
+
+  def compile_to_env_catalog(string, code_id=nil)
     Puppet[:code] = string
-    env = Puppet::Node::Environment.create("test", ["/dev/null"])
-    Puppet::Parser::EnvironmentCompiler.compile(env).filter { |r| r.virtual? }
+    Puppet::Parser::EnvironmentCompiler.compile(env, code_id).filter { |r| r.virtual? }
   end
 
-
-  before :each do
-    with_app_management(true)
-    Puppet::Type.newtype :cap, :is_capability => true do
-      newparam :name
-      newparam :host
+  around :each do |example|
+    Puppet[:app_management] = true
+    Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+    Puppet::Parser::EnvironmentCompiler.any_instance.stubs(:loaders).returns(loaders)
+    Puppet.override(:loaders => loaders, :current_environment => env) do
+      Puppet::Type.newtype :cap, :is_capability => true do
+        newparam :name
+        newparam :host
+      end
+      example.run
+      Puppet::Type.rmtype(:cap)
     end
-  end
-
-  after :each do
-    Puppet::Type.rmtype(:cap)
-    with_app_management(false)
+    Puppet[:app_management] = false
   end
 
   MANIFEST = <<-EOS
@@ -318,29 +317,29 @@ MANIFEST_WITH_CLASS = <<-EOS
 EOS
 
 
-  describe "a node catalog" do
+  context 'a node catalog' do
     it "is unaffected for a non-participating node" do
-      catalog = compile_to_catalog(MANIFEST, Puppet::Node.new('other'))
+      catalog = compile_to_catalog(MANIFEST, Puppet::Node.new('other', :environment => env))
       types = catalog.resource_keys.map { |type, _| type }.uniq.sort
       expect(types).to eq(["Class", "Stage"])
     end
 
     it "an application instance must be contained in a site" do
-      expect { compile_to_catalog(FAULTY_MANIFEST, Puppet::Node.new('first'))
+      expect { compile_to_catalog(FAULTY_MANIFEST, Puppet::Node.new('first', :environment => env))
       }.to raise_error(/Application instances .* can only be contained within a Site/)
     end
 
     it "does not raise an error when node mappings are not provided" do
-      expect { compile_to_catalog(MANIFEST_WO_NODE) }.to_not raise_error
+      expect { compile_to_catalog(MANIFEST_WO_NODE, node) }.to_not raise_error
     end
 
     it "raises an error if node mapping is a string" do
-      expect { compile_to_catalog(MANIFEST_WITH_STRING_NODES)
+      expect { compile_to_catalog(MANIFEST_WITH_STRING_NODES, node)
       }.to raise_error(/Invalid node mapping in .*: Mapping must be a hash/)
     end
 
     it "raises an error if node mapping is false" do
-      expect { compile_to_catalog(MANIFEST_WITH_FALSE_NODES)
+      expect { compile_to_catalog(MANIFEST_WITH_FALSE_NODES, node)
       }.to raise_error(/Invalid node mapping in .*: Mapping must be a hash/)
     end
 
@@ -360,7 +359,7 @@ EOS
     end
 
     context "for producing node" do
-      let(:compiled_node) { Puppet::Node.new('first') }
+      let(:compiled_node) { Puppet::Node.new('first', :environment => env) }
       let(:compiled_catalog) { compile_to_catalog(MANIFEST, compiled_node)}
 
       { "App[anapp]"         => 'application instance',
@@ -379,7 +378,7 @@ EOS
     end
 
     context "for consuming node" do
-      let(:compiled_node) { Puppet::Node.new('second') }
+      let(:compiled_node) { Puppet::Node.new('second', :environment => env) }
       let(:compiled_catalog) { compile_to_catalog(MANIFEST, compiled_node)}
       let(:cap) {
         the_cap = Puppet::Resource.new("Cap", "cap")
@@ -407,7 +406,7 @@ EOS
     end
 
     context "for node with class producer" do
-      let(:compiled_node) { Puppet::Node.new('first') }
+      let(:compiled_node) { Puppet::Node.new('first', :environment => env) }
       let(:compiled_catalog) { compile_to_catalog(MANIFEST_WITH_CLASS, compiled_node)}
 
       { "App[anapp]"      => 'application instance',
@@ -427,7 +426,7 @@ EOS
     end
 
     context "for node with class consumer" do
-      let(:compiled_node) { Puppet::Node.new('second') }
+      let(:compiled_node) { Puppet::Node.new('second', :environment => env) }
       let(:compiled_catalog) { compile_to_catalog(MANIFEST_WITH_CLASS, compiled_node)}
       let(:cap) {
         the_cap = Puppet::Resource.new("Cap", "cap")
@@ -460,7 +459,7 @@ EOS
       # that are used to instantiate an application. The application instances are needed.
       #
       it "the node expressions is evaluated" do
-        catalog = compile_to_catalog(MANIFEST_WITH_SITE, Puppet::Node.new('other'))
+        catalog = compile_to_catalog(MANIFEST_WITH_SITE, Puppet::Node.new('other', :environment => env))
         types = catalog.resource_keys.map { |type, _| type }.uniq.sort
         expect(types).to eq(["Class", "Node", "Notify", "Stage"])
         expect(catalog.resource("Notify[on a node]")).to_not be_nil
@@ -471,7 +470,7 @@ EOS
 
     context "when using a site expression" do
       it "the site expression is not evaluated in a node compilation" do
-        catalog = compile_to_catalog(MANIFEST_WITH_SITE, Puppet::Node.new('other'))
+        catalog = compile_to_catalog(MANIFEST_WITH_SITE, Puppet::Node.new('other', :environment => env))
         types = catalog.resource_keys.map { |type, _| type }.uniq.sort
         expect(types).to eq(["Class", "Node", "Notify", "Stage"])
         expect(catalog.resource("Notify[on a node]")).to_not be_nil
@@ -574,12 +573,22 @@ EOS
         }.to raise_error(/Only application components can appear inside a site - Notify\[fail me\] is not allowed at line 20/)
       end
     end
+
+    it "includes code_id if specified" do
+      catalog = compile_to_env_catalog(MANIFEST_WITH_SITE, "12345")
+      expect(catalog.code_id).to eq("12345")
+    end
+
+    it "omits code_id if unspecified" do
+      catalog = compile_to_env_catalog(MANIFEST_WITH_SITE)
+      expect(catalog.code_id).to be_nil
+    end
   end
 
 
   describe "when validation of nodes" do
     it 'validates that the key of a node mapping is a Node' do
-      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('other'))
+      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('other', :environment => env))
         application app {
         }
 
@@ -595,7 +604,7 @@ EOS
     end
 
     it 'validates that the value of a node mapping is a resource' do
-      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('other'))
+      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('other', :environment => env))
         application app {
         }
 
@@ -611,7 +620,7 @@ EOS
     end
 
     it 'validates that the value can be an array or resources' do
-      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('other'))
+      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('other', :environment => env))
         define p {
           notify {$title:}
         }
@@ -633,7 +642,7 @@ EOS
     end
 
     it 'validates that the is bound to exactly one node' do
-      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('first'))
+      expect { compile_to_catalog(<<-EOS, Puppet::Node.new('first', :environment => env))
         define p {
           notify {$title:}
         }

data/spec/unit/capability_spec.rb

@@ -1,33 +1,30 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
-require_relative 'pops/parser/parser_rspec_helper'
 
-describe "Capability types" do
+describe 'Capability types' do
   include PuppetSpec::Compiler
-  # We pull this in because we need access to with_app_management; and
-  # since that has to root around in the guts of the Pops parser, there's
-  # no really elegant way to do this
-  include ParserRspecHelper
-
-  def make_cap_type
-    Puppet::Type.newtype :cap, :is_capability => true do
-      newparam :name
-      newparam :host
+  let(:env) { Puppet::Node::Environment.create(:testing, []) }
+  let(:node) { Puppet::Node.new('test', :environment => env) }
+  let(:loaders) { Puppet::Pops::Loaders.new(env) }
+
+  around :each do |example|
+    Puppet[:app_management] = true
+    Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+    Puppet.override(:loaders => loaders, :current_environment => env) do
+      Puppet::Type.newtype :cap, :is_capability => true do
+        newparam :name
+        newparam :host
+      end
+      example.run
+      Puppet::Type.rmtype(:cap)
     end
+    Puppet[:app_management] = false
   end
 
-  before :each do
-    with_app_management(true)
-  end
-
-  after :each do
-    with_app_management(false)
-  end
-
-  describe "annotations" do
+  context 'annotations' do
     it "adds a blueprint for a produced resource" do
-      catalog = compile_to_catalog(<<-MANIFEST)
+      catalog = compile_to_catalog(<<-MANIFEST, node)
       define test($hostname) {
         notify { "hostname ${hostname}":}
       }
@@ -49,7 +46,7 @@ describe "Capability types" do
     end
 
     it "adds a blueprint for a consumed resource" do
-      catalog = compile_to_catalog(<<-MANIFEST)
+      catalog = compile_to_catalog(<<-MANIFEST, node)
       define test($hostname) {
         notify { "hostname ${hostname}":}
       }
@@ -136,7 +133,7 @@ describe "Capability types" do
     end
     it "does not allow operator '+>' in a mapping" do
       expect do
-      compile_to_catalog(<<-MANIFEST)
+      compile_to_catalog(<<-MANIFEST, node)
         define test($hostname) {
           notify { "hostname ${hostname}":}
         }
@@ -150,7 +147,7 @@ describe "Capability types" do
 
     it "does not allow operator '*=>' in a mapping" do
       expect do
-        compile_to_catalog(<<-MANIFEST)
+        compile_to_catalog(<<-MANIFEST, node)
         define test($hostname) {
           notify { "hostname ${hostname}":}
         }
@@ -163,9 +160,8 @@ describe "Capability types" do
     end
 
     it "does not allow 'before' relationship to capability mapping" do
-      make_cap_type
       expect do
-        compile_to_catalog(<<-MANIFEST)
+        compile_to_catalog(<<-MANIFEST, node)
         define test() {
           notify { "hello":}
         }
@@ -186,22 +182,14 @@ describe "Capability types" do
       MANIFEST
 
         expect {
-          compile_to_catalog(manifest)
+          compile_to_catalog(manifest, node)
         }.to raise_error(Puppet::Error,
                          /#{kw} clause references nonexistent type Test/)
       end
     end
   end
 
-  describe "exporting a capability" do
-    before(:each) do
-      make_cap_type
-    end
-
-    after :each do
-      Puppet::Type.rmtype(:cap)
-    end
-
+  context 'exporting a capability' do
     it "does not add produced resources that are not exported" do
       manifest = <<-MANIFEST
 define test($hostname) {
@@ -214,7 +202,7 @@ Test produces Cap {
 
 test { one: hostname => "ahost" }
     MANIFEST
-      catalog = compile_to_catalog(manifest)
+      catalog = compile_to_catalog(manifest, node)
       expect(catalog.resource("Test[one]")).to be_instance_of(Puppet::Resource)
       expect(catalog.resource_keys.find { |type, _| type == "Cap" }).to be_nil
     end
@@ -236,7 +224,7 @@ Test produces Cap {
 
 test { one: hostname => "ahost", export => Cap[two] }
     MANIFEST
-      catalog = compile_to_catalog(manifest)
+      catalog = compile_to_catalog(manifest, node)
       expect(catalog.resource("Test[one]")).to be_instance_of(Puppet::Resource)
 
       caps = catalog.resource_keys.select { |type, _| type == "Cap" }
@@ -247,19 +235,11 @@ test { one: hostname => "ahost", export => Cap[two] }
       expect(cap["require"]).to eq("Test[one]")
       expect(cap["host"]).to eq("ahost")
       expect(cap.resource_type).to eq(Puppet::Type::Cap)
-      expect(cap.tags.any? { |t| t == "producer:production" }).to eq(true)
+      expect(cap.tags.any? { |t| t == 'producer:testing' }).to eq(true)
     end
   end
 
-  describe "consuming a capability" do
-    before(:each) do
-      make_cap_type
-    end
-
-    after :each do
-      Puppet::Type.rmtype(:cap)
-    end
-
+  context 'consuming a capability' do
     def make_catalog(instance)
       manifest = <<-MANIFEST
       define test($hostname = nohost) {
@@ -270,7 +250,7 @@ test { one: hostname => "ahost", export => Cap[two] }
         hostname => $host
       }
     MANIFEST
-      compile_to_catalog(manifest + instance)
+      compile_to_catalog(manifest + instance, node)
     end
 
     def mock_cap_finding
@@ -322,10 +302,10 @@ test { one: hostname => "ahost", export => Cap[two] }
       end
     end
 
-    describe 'producing/consuming resources' do
+    context 'producing/consuming resources' do
 
       let(:ral) do
-        compile_to_ral(<<-MANIFEST)
+        compile_to_ral(<<-MANIFEST, node)
   define producer() {
     notify { "producer":}
   }
@@ -365,10 +345,10 @@ test { one: hostname => "ahost", export => Cap[two] }
       end
     end
 
-    describe 'producing/consuming resources to/from classes' do
+    context 'producing/consuming resources to/from classes' do
 
       let(:ral) do
-        compile_to_ral(<<-MANIFEST)
+        compile_to_ral(<<-MANIFEST, node)
   define test($hostname) {
     notify { $hostname:}
   }