puppet 4.2.3-x64-mingw32 → 4.3.0-x64-mingw32

data/spec/unit/provider/sshkey/parsed_spec.rb

@@ -68,4 +68,27 @@ describe "sshkey parsed provider" do
       end
     end
   end
+
+  context 'default ssh_known_hosts target path' do
+    ['9.10', '9.11', '10.10'].each do |version|
+      it 'should be `/etc/ssh_known_hosts` when OSX version 10.10 or older`' do
+        Facter.expects(:value).with(:operatingsystem).returns('Darwin')
+        Facter.expects(:value).with(:macosx_productversion_major).returns(version)
+        expect(subject.default_target).to eq('/etc/ssh_known_hosts')
+      end
+    end
+
+    ['10.11', '10.13', '11.0', '11.11'].each do |version|
+      it 'should be `/etc/ssh/ssh_known_hosts` when OSX version 10.11 or newer`' do
+        Facter.expects(:value).with(:operatingsystem).returns('Darwin')
+        Facter.expects(:value).with(:macosx_productversion_major).returns(version)
+        expect(subject.default_target).to eq('/etc/ssh/ssh_known_hosts')
+      end
+    end
+
+    it 'should be `/etc/ssh/ssh_known_hosts` on other operating systems' do
+      Facter.expects(:value).with(:operatingsystem).returns('RedHat')
+      expect(subject.default_target).to eq('/etc/ssh/ssh_known_hosts')
+    end
+  end
 end

data/spec/unit/reports_spec.rb

@@ -43,6 +43,16 @@ describe Puppet::Reports, " when registering report types" do
     Puppet::Reports.register_report(:testing) { }
   end
 
+  it "should allow a successful report to be reloaded" do
+    Puppet::Reports.register_report(:testing) { }
+    Puppet::Reports.register_report(:testing) { }
+  end
+
+  it "should allow a failed report to be reloaded and show the correct exception both times" do
+    expect { Puppet::Reports.register_report(:testing) { raise TypeError, 'failed report' } }.to raise_error(TypeError)
+    expect { Puppet::Reports.register_report(:testing) { raise TypeError, 'failed report' } }.to raise_error(TypeError)
+  end
+
   it "should extend the report type with the Puppet::Util::Docs module" do
     mod = stub 'module', :define_method => true
 

data/spec/unit/resource/capability_finder_spec.rb

@@ -0,0 +1,56 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require_relative '../pops/parser/parser_rspec_helper'
+require 'puppet/resource/capability_finder'
+
+describe Puppet::Resource::CapabilityFinder do
+  context 'when PuppetDB is not configured' do
+    it 'should error' do
+      Puppet::Util.expects(:const_defined?).with('Puppetdb').returns false
+      expect { Puppet::Resource::CapabilityFinder.find('production', nil, nil) }.to raise_error(/PuppetDB is not available/)
+    end
+  end
+
+  context 'when PuppetDB is configured' do
+    around(:each) do |example|
+      mock_pdb = !Puppet::Util.const_defined?('Puppetdb')
+      if mock_pdb
+        class Puppet::Util::Puppetdb
+          class Http; end
+        end
+      end
+      begin
+        make_cap_type
+        example.run
+      ensure
+        Puppet::Util.send(:remove_const, 'Puppetdb') if mock_pdb
+      end
+    end
+
+    class MockResponse
+      def body
+        '[{"type": "Cap", "title": "cap", "parameters": { "host" : "ahost" }}]'
+      end
+    end
+
+    def make_cap_type
+      Puppet::Type.newtype :cap, :is_capability => true do
+        newparam :name
+        newparam :host
+      end
+    end
+
+    it 'should call Puppet::Util::PuppetDB::Http.action' do
+      Puppet::Util::Puppetdb::Http.expects(:action).returns(MockResponse.new)
+      result = Puppet::Resource::CapabilityFinder.find('production', nil, Puppet::Resource.new('Cap', 'cap'))
+      expect(result['host']).to eq('ahost')
+    end
+
+    it 'should use pass code_id in query to Puppet::Util::PuppetDB::Http.action' do
+      code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+      Puppet::Util::Puppetdb::Http.expects(:action).with(regexp_matches(Regexp.new(CGI.escape('"=","code_id","' + code_id + "")))).returns(MockResponse.new)
+      result = Puppet::Resource::CapabilityFinder.find('production', code_id, Puppet::Resource.new('Cap', 'cap'))
+      expect(result['host']).to eq('ahost')
+    end
+  end
+end

data/spec/unit/resource/catalog_spec.rb

@@ -86,6 +86,11 @@ describe Puppet::Resource::Catalog, "when compiling" do
     expect(@catalog.server_version).to eq(5)
   end
 
+  it "defaults code_id to nil" do
+    catalog = Puppet::Resource::Catalog.new("host")
+    expect(catalog.code_id).to be_nil
+  end
+
   describe "when compiling" do
     it "should accept tags" do
       config = Puppet::Resource::Catalog.new("mynode")
@@ -253,6 +258,16 @@ describe Puppet::Resource::Catalog, "when compiling" do
         r == @r1
       end.edge?(@r1,@r2)).not_to be
     end
+
+    it "copies the version" do
+      @original.version = '123'
+      expect(@original.filter.version).to eq(@original.version)
+    end
+
+    it 'copies the code_id' do
+      @original.code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+      expect(@original.filter.code_id).to eq(@original.code_id)
+    end
   end
 
   describe "when functioning as a resource container" do
@@ -782,17 +797,23 @@ describe Puppet::Resource::Catalog, "when converting to pson" do
     @catalog = Puppet::Resource::Catalog.new("myhost")
   end
 
-  def pson_output_should
-    @catalog.class.expects(:from_data_hash).with { |hash| yield hash }.returns(:something)
+  { :name => 'myhost',
+    :version => 42,
+    :code_id => 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+  }.each do |param, value|
+    it "emits a #{param} equal to #{value.inspect}" do
+      @catalog.send(param.to_s + "=", value)
+      pson = PSON.parse(@catalog.to_pson)
+
+      expect(pson[param.to_s]).to eq(@catalog.send(param))
+    end
   end
 
-  [:name, :version, :classes].each do |param|
-    it "should set its #{param} to the #{param} of the resource" do
-      @catalog.send(param.to_s + "=", "testing") unless @catalog.send(param)
+  it "emits an array of classes" do
+    @catalog.add_class('foo')
+    pson = PSON.parse(@catalog.to_pson)
 
-      pson_output_should { |hash| expect(hash[param.to_s]).to eq(@catalog.send(param)) }
-      Puppet::Resource::Catalog.from_data_hash PSON.parse @catalog.to_pson
-    end
+    expect(pson['classes']).to eq(['foo'])
   end
 
   it "should convert its resources to a PSON-encoded array and store it as the 'resources' data" do
@@ -831,6 +852,7 @@ describe Puppet::Resource::Catalog, "when converting from pson" do
 
   it "should create it with the provided name" do
     @data['version'] = 50
+    @data['code_id'] = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
     @data['tags'] = %w{one two}
     @data['classes'] = %w{one two}
     @data['edges'] = [Puppet::Relationship.new("File[/foo]", "File[/bar]",
@@ -844,6 +866,7 @@ describe Puppet::Resource::Catalog, "when converting from pson" do
 
     expect(catalog.name).to eq('myhost')
     expect(catalog.version).to eq(@data['version'])
+    expect(catalog.code_id).to eq(@data['code_id'])
     expect(catalog).to be_tagged("one")
     expect(catalog).to be_tagged("two")
 

data/spec/unit/resource/type_collection_spec.rb

@@ -76,16 +76,18 @@ describe Puppet::Resource::TypeCollection do
     end.to raise_error(Puppet::ParseError, /cannot be redefined/)
   end
 
-  it "should remove all nodes, classes, and definitions when cleared" do
+  it "should remove all nodes, classes, definitions, and applications when cleared" do
     loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add Puppet::Resource::Type.new(:hostclass, "class")
     loader.add Puppet::Resource::Type.new(:definition, "define")
     loader.add Puppet::Resource::Type.new(:node, "node")
+    loader.add Puppet::Resource::Type.new(:application, "application")
 
     loader.clear
     expect(loader.hostclass("class")).to be_nil
     expect(loader.definition("define")).to be_nil
     expect(loader.node("node")).to be_nil
+    expect(loader.node("application")).to be_nil
   end
 
   describe "when looking up names" do
@@ -153,7 +155,8 @@ describe Puppet::Resource::TypeCollection do
     end
   end
 
-  %w{hostclass node definition}.each do |data|
+  KINDS = %w{hostclass node definition application}
+  KINDS.each do |data|
     describe "behavior of add for #{data}" do
 
       it "should return the added #{data}" do
@@ -175,6 +178,24 @@ describe Puppet::Resource::TypeCollection do
       it "should return nil when asked for a #{data} that has not been added" do
         expect(Puppet::Resource::TypeCollection.new(environment).send(data, "foo")).to be_nil
       end
+
+      if data != "node"
+        it "should fail if an application with the same name is added" do
+          loader = Puppet::Resource::TypeCollection.new(environment)
+          instance = Puppet::Resource::Type.new(data, "foo")
+          application = Puppet::Resource::Type.new(:application, "foo")
+          loader.add(instance)
+          expect { loader.add(application) }.to raise_error(Puppet::ParseError, /redefine/)
+        end
+
+        it "should fail if there is an application with the same name" do
+          loader = Puppet::Resource::TypeCollection.new(environment)
+          application = Puppet::Resource::Type.new(:application, "foo")
+          instance = Puppet::Resource::Type.new(data, "foo")
+          loader.add(instance)
+          expect { loader.add(application) }.to raise_error(Puppet::ParseError, /redefine/)
+        end
+      end
     end
   end
 

data/spec/unit/resource/type_spec.rb

@@ -766,7 +766,7 @@ describe Puppet::Resource::Type do
       source = Puppet::Resource::Type.new(:hostclass, "foo", :code => scode)
 
       dest.merge(source)
-      expect(dest.code.children.collect { |l| l.children[0].value }).to eq(%w{dest source})
+      expect(dest.code.children.map { |c| c.value }).to eq(%w{dest source})
     end
   end
 end

data/spec/unit/resource_spec.rb

@@ -331,13 +331,15 @@ describe Puppet::Resource do
         end
 
         it "should query the data_binding terminus using a namespaced key" do
+          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
           Puppet::DataBinding.indirection.expects(:find).with(
             'apache::port', all_of(has_key(:environment), has_key(:variables)))
           resource.set_default_parameters(scope)
         end
 
         it "should use the value from the data_binding terminus" do
-          Puppet::DataBinding.indirection.expects(:find).returns('443')
+          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns('443')
 
           resource.set_default_parameters(scope)
 
@@ -345,7 +347,8 @@ describe Puppet::Resource do
         end
 
         it "should use the default value if the data_binding terminus returns nil" do
-          Puppet::DataBinding.indirection.expects(:find).returns(nil)
+          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns(nil)
 
           resource.set_default_parameters(scope)
 
@@ -353,7 +356,8 @@ describe Puppet::Resource do
         end
 
         it "should fail with error message about data binding on a hiera failure" do
-          Puppet::DataBinding.indirection.expects(:find).raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
+          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
           expect {
             resource.set_default_parameters(scope)
           }.to raise_error(Puppet::Error, /Error from DataBinding 'hiera' while looking up 'apache::port':.*Forgettabotit/)
@@ -428,7 +432,7 @@ describe Puppet::Resource do
     end
 
     it "should fail if invalid parameters are used" do
-      expect { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.to raise_error(ArgumentError, /Invalid parameter/)
+      expect { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.to raise_error(Puppet::Error, /no parameter named 'nosuchparam'/)
     end
 
     it "should fail if the resource type cannot be resolved" do
@@ -657,6 +661,20 @@ describe Puppet::Resource do
       )
     end
 
+    it "should escape internal single quotes in a title" do
+      singlequote_resource = Puppet::Resource.new("one::two", "/my/file'b'a'r",
+        :parameters => {
+          :ensure => 'present',
+        }
+      )
+      expect(singlequote_resource.to_manifest).to eq <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
+        one::two { '/my/file\\'b\\'a\\'r':
+          ensure => 'present',
+        }
+      HEREDOC
+
+    end
+
     it "should align, sort and add trailing commas to attributes with ensure first" do
       expect(@resource.to_manifest).to eq <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
         one::two { '/my/file':

data/spec/unit/settings_spec.rb

@@ -287,6 +287,95 @@ describe Puppet::Settings do
       expect(@settings.set_by_cli?(:myval)).to be_falsey
     end
 
+    it "should find no configured settings by default" do
+      expect(@settings.set_by_config?(:myval)).to be_falsey
+    end
+
+    it "should identify configured settings in memory" do
+      @settings.instance_variable_get(:@value_sets)[:memory].expects(:lookup).with(:myval).returns('foo')
+      expect(@settings.set_by_config?(:myval)).to be_truthy
+    end
+
+    it "should identify configured settings from CLI" do
+      @settings.instance_variable_get(:@value_sets)[:cli].expects(:lookup).with(:myval).returns('foo')
+      expect(@settings.set_by_config?(:myval)).to be_truthy
+    end
+
+    it "should not identify configured settings from environment by default" do
+      Puppet.lookup(:environments).expects(:get_conf).with(Puppet[:environment].to_sym).never
+      expect(@settings.set_by_config?(:manifest)).to be_falsey
+    end
+
+    it "should identify configured settings from environment by when an environment is specified" do
+      foo = mock('environment', :manifest => 'foo')
+      Puppet.lookup(:environments).expects(:get_conf).with(Puppet[:environment].to_sym).returns(foo)
+      expect(@settings.set_by_config?(:manifest, Puppet[:environment])).to be_truthy
+    end
+
+    it "should identify configured settings from the preferred run mode" do
+      user_config_text = "[#{@settings.preferred_run_mode}]\nmyval = foo"
+      seq = sequence "config_file_sequence"
+
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
+        with(user_config_file_default_location).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
+        with(user_config_file_default_location).
+        returns(user_config_text).in_sequence(seq)
+
+      @settings.send(:parse_config_files)
+      expect(@settings.set_by_config?(:myval)).to be_truthy
+    end
+
+    it "should identify configured settings from the specified run mode" do
+      user_config_text = "[master]\nmyval = foo"
+      seq = sequence "config_file_sequence"
+
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
+        with(user_config_file_default_location).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
+        with(user_config_file_default_location).
+        returns(user_config_text).in_sequence(seq)
+
+      @settings.send(:parse_config_files)
+      expect(@settings.set_by_config?(:myval, nil, :master)).to be_truthy
+    end
+
+    it "should not identify configured settings from an unspecified run mode" do
+      user_config_text = "[zaz]\nmyval = foo"
+      seq = sequence "config_file_sequence"
+
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
+        with(user_config_file_default_location).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
+        with(user_config_file_default_location).
+        returns(user_config_text).in_sequence(seq)
+
+      @settings.send(:parse_config_files)
+      expect(@settings.set_by_config?(:myval)).to be_falsey
+    end
+
+    it "should identify configured settings from the main section" do
+      user_config_text = "[main]\nmyval = foo"
+      seq = sequence "config_file_sequence"
+
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
+        with(user_config_file_default_location).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
+        with(user_config_file_default_location).
+        returns(user_config_text).in_sequence(seq)
+
+      @settings.send(:parse_config_files)
+      expect(@settings.set_by_config?(:myval)).to be_truthy
+    end
+
     it "should clear the cache when setting getopt-specific values" do
       @settings.define_settings :mysection,
           :one => { :default => "whah", :desc => "yay" },
@@ -1734,7 +1823,7 @@ describe Puppet::Settings do
   end
 
   describe "default_certname" do
-    describe "using hostname and domainname" do
+    describe "using hostname and domain" do
       before :each do
         Puppet::Settings.stubs(:hostname_fact).returns("testhostname")
         Puppet::Settings.stubs(:domain_fact).returns("domain.test.")

data/spec/unit/ssl/certificate_authority/interface_spec.rb

@@ -332,9 +332,10 @@ describe Puppet::SSL::CertificateAuthority::Interface do
           @applier.expects(:puts).with "h1"
 
           @ca.expects(:print).with("host2").returns nil
-          Puppet.expects(:err).with { |msg| msg.include?("host2") }
-
-          @applier.apply(@ca)
+    
+	  expect {
+            @applier.apply(@ca)
+	  }.to raise_error(ArgumentError, /Could not find certificate for host2/)
         end
       end
     end

data/spec/unit/ssl/oids_spec.rb

@@ -25,6 +25,14 @@ describe Puppet::SSL::Oids do
       'pp_department'       => "1.3.6.1.4.1.34380.1.1.15",
       'pp_cluster'          => "1.3.6.1.4.1.34380.1.1.16",
       'pp_provisioner'      => "1.3.6.1.4.1.34380.1.1.17",
+      'pp_region'           => "1.3.6.1.4.1.34380.1.1.18",
+      'pp_datacenter'       => "1.3.6.1.4.1.34380.1.1.19",
+      'pp_zone'             => "1.3.6.1.4.1.34380.1.1.20",
+      'pp_network'          => "1.3.6.1.4.1.34380.1.1.21",
+      'pp_securitypolicy'   => "1.3.6.1.4.1.34380.1.1.22",
+      'pp_cloudplatform'    => "1.3.6.1.4.1.34380.1.1.23",
+      'pp_apptier'          => "1.3.6.1.4.1.34380.1.1.24",
+      'pp_hostname'         => "1.3.6.1.4.1.34380.1.1.25",
       'ppPrivCertExt'       => '1.3.6.1.4.1.34380.1.2',
     }.each_pair do |sn, oid|
       it "defines #{sn} as #{oid}" do

data/spec/unit/transaction/additional_resource_generator_spec.rb

@@ -52,6 +52,48 @@ describe Puppet::Transaction::AdditionalResourceGenerator do
     end
   end
 
+  Puppet::Type.newtype(:autorequire) do
+    newparam(:name) do
+      isnamevar
+    end
+
+    autorequire(:notify) do
+      self[:name]
+    end
+  end
+
+  Puppet::Type.newtype(:gen_auto) do
+    newparam(:name) do
+      isnamevar
+    end
+
+    newparam(:eval_after) do
+    end
+
+    def generate()
+      [ Puppet::Type.type(:autorequire).new(:name => self[:eval_after]) ]
+    end
+  end
+
+  Puppet::Type.newtype(:empty) do
+    newparam(:name) do
+      isnamevar
+    end
+  end
+
+  Puppet::Type.newtype(:gen_empty) do
+    newparam(:name) do
+      isnamevar
+    end
+
+    newparam(:eval_after) do
+    end
+
+    def generate()
+      [ Puppet::Type.type(:empty).new(:name => self[:eval_after], :require => "Notify[#{self[:eval_after]}]") ]
+    end
+  end
+
   context "when applying eval_generate" do
     it "should add the generated resources to the catalog" do
       catalog = compile_to_ral(<<-MANIFEST)
@@ -368,13 +410,44 @@ describe Puppet::Transaction::AdditionalResourceGenerator do
                          "Notify[after]"))
     end
 
-    def relationships_after_generating(manifest, resource_to_generate)
-      catalog = compile_to_ral(manifest)
-      relationship_graph = relationship_graph_for(catalog)
+    it "runs autorequire on the generated resource" do
+      graph = relationships_after_generating(<<-MANIFEST, 'Gen_auto[thing]')
+        gen_auto { thing:
+          eval_after => hello,
+        }
 
-      generate_resources_in(catalog, relationship_graph, resource_to_generate)
+        notify { hello: }
+        notify { goodbye: }
+      MANIFEST
 
-      relationship_graph
+      expect(order_resources_traversed_in(graph)).to(
+        include_in_order("Gen_auto[thing]",
+                         "Notify[hello]",
+                         "Autorequire[hello]",
+                         "Notify[goodbye]"))
+    end
+
+    it "evaluates metaparameters on the generated resource" do
+      graph = relationships_after_generating(<<-MANIFEST, 'Gen_empty[thing]')
+        gen_empty { thing:
+          eval_after => hello,
+        }
+
+        notify { hello: }
+        notify { goodbye: }
+      MANIFEST
+
+      expect(order_resources_traversed_in(graph)).to(
+        include_in_order("Gen_empty[thing]",
+                         "Notify[hello]",
+                         "Empty[hello]",
+                         "Notify[goodbye]"))
+    end
+
+    def relationships_after_generating(manifest, resource_to_generate)
+      catalog = compile_to_ral(manifest)
+      generate_resources_in(catalog, nil, resource_to_generate)
+      relationship_graph_for(catalog)
     end
 
     def generate_resources_in(catalog, relationship_graph, resource_to_generate)