puppet 4.0.0 → 4.5.0

data/spec/unit/type/vlan_spec.rb

@@ -38,7 +38,7 @@ describe Puppet::Type.type(:vlan) do
     end
 
     it "should fail if vlan name is not a number" do
-      expect { Puppet::Type.type(:vlan).new(:name => "notanumber", :ensure => :present) }.to raise_error
+      expect { Puppet::Type.type(:vlan).new(:name => "notanumber", :ensure => :present) }.to raise_error(Puppet::ResourceError, /Parameter name failed on Vlan/)
     end
   end
 end

data/spec/unit/type/yumrepo_spec.rb

@@ -49,9 +49,9 @@ shared_examples_for "a yumrepo parameter that expects a boolean parameter" do |p
       instance = described_class.new(:name => 'puppetlabs', param => value)
       expect(instance[param]).to eq value
     end
-    it "accepts #{value} downcased to #{value.downcase}" do
+    it "accepts #{value} downcased to #{value.downcase} and capitalizes it" do
       instance = described_class.new(:name => 'puppetlabs', param => value.downcase)
-      expect(instance[param]).to eq value.downcase
+      expect(instance[param]).to eq value.downcase.capitalize
     end
     it "fails on valid value #{value} contained in another value" do
         expect {

data/spec/unit/type_spec.rb

@@ -522,7 +522,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should fail if any invalid attributes have been provided" do
-      expect { Puppet::Type.type(:mount).new(:title => "/foo", :nosuchattr => "whatever") }.to raise_error(Puppet::Error, /Invalid parameter/)
+      expect { Puppet::Type.type(:mount).new(:title => "/foo", :nosuchattr => "whatever") }.to raise_error(Puppet::Error, /no parameter named 'nosuchattr'/)
     end
 
     context "when an attribute fails validation" do
@@ -709,6 +709,20 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       @resource.property(:ensure).stubs(:retrieve).returns :absent
     end
 
+    it "should always retrieve the ensure value by default" do
+      @ensurable_resource = Puppet::Type.type(:file).new(:name => "/not/existent", :mode => "0644")
+      Puppet::Type::File::Ensure.stubs(:ensure).returns :absent
+      Puppet::Type::File::Ensure.any_instance.expects(:retrieve).once
+      @ensurable_resource.retrieve_resource
+    end
+
+    it "should not retrieve the ensure value if specified" do
+      @ensurable_resource = Puppet::Type.type(:service).new(:name => "DummyService", :enable => true)
+      @ensurable_resource.properties.each { |prop| prop.stubs(:retrieve) }
+      Puppet::Type::Service::Ensure.any_instance.expects(:retrieve).never
+      @ensurable_resource.retrieve_resource
+    end
+
     it "should fail if its provider is unsuitable" do
       @resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
       @resource.provider.class.expects(:suitable?).returns false

data/spec/unit/util/feature_spec.rb

@@ -89,7 +89,7 @@ describe Puppet::Util::Feature do
   end
 
   it "should cache load failures when configured to do so" do
-    Puppet[:always_cache_features] = true
+    Puppet[:always_retry_plugins] = false
 
     @features.add(:myfeature, :libs => %w{foo bar})
     @features.expects(:require).with("foo").raises(LoadError)

data/spec/unit/util/filetype_spec.rb

@@ -183,7 +183,7 @@ describe Puppet::Util::FileType do
     let(:crontab_output) { 'suntab_output' }
 
     # possible crontab output was taken from here:
-    # http://docs.oracle.com/cd/E19082-01/819-2380/sysrescron-60/index.html
+    # https://docs.oracle.com/cd/E19082-01/819-2380/sysrescron-60/index.html
     let(:absent_crontab) do
       'crontab: can\'t open your crontab file'
     end

data/spec/unit/util/http_proxy_spec.rb

@@ -122,4 +122,91 @@ describe Puppet::Util::HttpProxy do
     end
 
   end
+
+  describe ".no_proxy?" do
+    no_proxy = '127.0.0.1, localhost, mydomain.com, *.otherdomain.com, oddport.com:8080, *.otheroddport.com:8080, .anotherdomain.com, .anotheroddport.com:8080'
+    it "should return false if no_proxy does not exist in env" do
+      Puppet::Util.withenv('no_proxy' => nil) do
+        dest = 'https://puppetlabs.com'
+        expect(subject.no_proxy?(dest)).to be false
+      end
+    end
+
+    it "should return false if the dest does not match any element in the no_proxy list" do
+      Puppet::Util.withenv('no_proxy' => no_proxy) do
+        dest = 'https://puppetlabs.com'
+        expect(subject.no_proxy?(dest)).to be false
+      end
+    end
+
+    it "should return true if the dest as an IP does match any element in the no_proxy list" do
+      Puppet::Util.withenv('no_proxy' => no_proxy) do
+        dest = 'http://127.0.0.1'
+        expect(subject.no_proxy?(dest)).to be true
+      end
+    end
+
+    it "should return true if the dest as single word does match any element in the no_proxy list" do
+      Puppet::Util.withenv('no_proxy' => no_proxy) do
+        dest = 'http://localhost'
+        expect(subject.no_proxy?(dest)).to be true
+      end
+    end
+
+    it "should return true if the dest as standard domain word does match any element in the no_proxy list" do
+      Puppet::Util.withenv('no_proxy' => no_proxy) do
+        dest = 'http://mydomain.com'
+        expect(subject.no_proxy?(dest)).to be true
+      end
+    end
+
+    it "should return true if the dest as standard domain with port does match any element in the no_proxy list" do
+      Puppet::Util.withenv('no_proxy' => no_proxy) do
+        dest = 'http://oddport.com:8080'
+        expect(subject.no_proxy?(dest)).to be true
+      end
+    end
+
+    it "should return false if the dest is standard domain not matching port" do
+      Puppet::Util.withenv('no_proxy' => no_proxy) do
+        dest = 'http://oddport.com'
+        expect(subject.no_proxy?(dest)).to be false
+      end
+    end
+
+    it "should return true if the dest does match any wildcarded element in the no_proxy list" do
+      Puppet::Util.withenv('no_proxy' => no_proxy) do
+        dest = 'http://sub.otherdomain.com'
+        expect(subject.no_proxy?(dest)).to be true
+      end
+    end
+
+    it "should return true if the dest does match any wildcarded element with port in the no_proxy list" do
+      Puppet::Util.withenv('no_proxy' => no_proxy) do
+        dest = 'http://sub.otheroddport.com:8080'
+        expect(subject.no_proxy?(dest)).to be true
+      end
+    end
+
+    it "should return true if the dest does match any domain level (no wildcard) element in the no_proxy list" do
+      Puppet::Util.withenv('no_proxy' => no_proxy) do
+        dest = 'http://sub.anotherdomain.com'
+        expect(subject.no_proxy?(dest)).to be true
+      end
+    end
+
+    it "should return true if the dest does match any domain level (no wildcard) element with port in the no_proxy list" do
+      Puppet::Util.withenv('no_proxy' => no_proxy) do
+        dest = 'http://sub.anotheroddport.com:8080'
+        expect(subject.no_proxy?(dest)).to be true
+      end
+    end
+
+    it "should work if passed a URI object" do
+      Puppet::Util.withenv('no_proxy' => no_proxy) do
+        dest = URI.parse('http://sub.otheroddport.com:8080')
+        expect(subject.no_proxy?(dest)).to be true
+      end
+    end
+  end
 end

data/spec/unit/util/ldap/generator_spec.rb

@@ -9,7 +9,7 @@ describe Puppet::Util::Ldap::Generator do
   end
 
   it "should require a parameter name at initialization" do
-    expect { Puppet::Util::Ldap::Generator.new }.to raise_error
+    expect { Puppet::Util::Ldap::Generator.new }.to raise_error(ArgumentError, /wrong number of arguments/)
   end
 
   it "should always return its name as a string" do

data/spec/unit/util/log/destinations_spec.rb

@@ -28,8 +28,6 @@ describe Puppet::Util::Log.desttypes[:file] do
   include PuppetSpec::Files
 
   before do
-    File.stubs(:open)           # prevent actually creating the file
-    File.stubs(:chown)          # prevent chown on non existing file from failing
     @class = Puppet::Util::Log.desttypes[:file]
   end
 

data/spec/unit/util/log_spec.rb

@@ -93,7 +93,120 @@ describe Puppet::Util::Log do
 
       expect(logs.collect(&:message)).to include("Inner block", "Outer block")
     end
+
+    it 'includes backtrace for RuntimeError in log message when trace is enabled' do
+      logs = []
+      destination = Puppet::Test::LogCollector.new(logs)
+
+      Puppet::Util::Log.newdestination(destination)
+      Puppet::Util::Log.with_destination(destination) do
+        begin
+          raise RuntimeError, 'Oops'
+        rescue RuntimeError => e
+          Puppet.log_exception(e, :default, :trace => true)
+        end
+      end
+      expect(logs.size).to eq(1)
+      log = logs[0]
+      expect(log.message).to match('/log_spec.rb')
+      expect(log.backtrace).to be_nil
+    end
+
+    it 'excludes backtrace for RuntimeError in log message when trace is disabled' do
+      logs = []
+      destination = Puppet::Test::LogCollector.new(logs)
+
+      Puppet::Util::Log.newdestination(destination)
+      Puppet::Util::Log.with_destination(destination) do
+        begin
+          raise RuntimeError, 'Oops'
+        rescue RuntimeError => e
+          Puppet.log_exception(e)
+        end
+      end
+      expect(logs.size).to eq(1)
+      log = logs[0]
+      expect(log.message).to_not match('/log_spec.rb')
+      expect(log.backtrace).to be_nil
+    end
+
+    it "backtrace is Array in 'backtrace' and excluded from 'message' when logging ParseErrorWithIssue with trace enabled" do
+      logs = []
+      destination = Puppet::Test::LogCollector.new(logs)
+
+      Puppet::Util::Log.newdestination(destination)
+      Puppet::Util::Log.with_destination(destination) do
+        begin
+          raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
+        rescue RuntimeError => e
+          Puppet.log_exception(e, :default, :trace => true)
+        end
+      end
+      expect(logs.size).to eq(1)
+      log = logs[0]
+      expect(log.message).to_not match('/log_spec.rb')
+      expect(log.backtrace).to be_a(Array)
+    end
+
+    it "backtrace is excluded when logging ParseErrorWithIssue with trace disabled" do
+      logs = []
+      destination = Puppet::Test::LogCollector.new(logs)
+
+      Puppet::Util::Log.newdestination(destination)
+      Puppet::Util::Log.with_destination(destination) do
+        begin
+          raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
+        rescue RuntimeError => e
+          Puppet.log_exception(e)
+        end
+      end
+      expect(logs.size).to eq(1)
+      log = logs[0]
+      expect(log.message).to_not match('/log_spec.rb')
+      expect(log.backtrace).to be_nil
+    end
+
+    it 'includes position details for ParseError in log message' do
+      logs = []
+      destination = Puppet::Test::LogCollector.new(logs)
+
+      Puppet::Util::Log.newdestination(destination)
+      Puppet::Util::Log.with_destination(destination) do
+        begin
+          raise Puppet::ParseError.new('Oops', '/tmp/test.pp', 30, 15)
+        rescue RuntimeError => e
+          Puppet.log_exception(e)
+        end
+      end
+      expect(logs.size).to eq(1)
+      log = logs[0]
+      expect(log.message).to match(/ at \/tmp\/test\.pp:30:15/)
+      expect(log.message).to be(log.to_s)
+    end
+
+    it 'excludes position details for ParseErrorWithIssue from log message' do
+      logs = []
+      destination = Puppet::Test::LogCollector.new(logs)
+
+      Puppet::Util::Log.newdestination(destination)
+      Puppet::Util::Log.with_destination(destination) do
+        begin
+          raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
+        rescue RuntimeError => e
+          Puppet.log_exception(e)
+        end
+      end
+      expect(logs.size).to eq(1)
+      log = logs[0]
+      expect(log.message).to_not match(/ at \/tmp\/test\.pp:30:15/)
+      expect(log.to_s).to match(/ at \/tmp\/test\.pp:30:15/)
+      expect(log.issue_code).to eq(:SYNTAX_ERROR)
+      expect(log.file).to eq('/tmp/test.pp')
+      expect(log.line).to eq(30)
+      expect(log.pos).to eq(15)
+    end
   end
+
   describe Puppet::Util::Log::DestConsole do
     before do
       @console = Puppet::Util::Log::DestConsole.new
@@ -311,7 +424,7 @@ describe Puppet::Util::Log do
         end
       end
 
-      it "should set the source to 'path', when available" do
+      it "should set the source to a type's 'path', when available" do
         source = Puppet::Type.type(:file).new :path => path
         source.tags = ["tag", "tag2"]
 
@@ -325,6 +438,17 @@ describe Puppet::Util::Log do
         expect(log.source).to eq("/File[#{path}]")
       end
 
+      it "should set the source to a provider's type's 'path', when available" do
+        source = Puppet::Type.type(:file).new :path => path
+        source.tags = ["tag", "tag2"]
+
+        log = Puppet::Util::Log.new(:level => "notice", :message => :foo)
+
+        log.source = source.provider
+
+        expect(log.source).to match Regexp.quote("File\[#{path}\]\(provider=")
+      end
+
       it "should copy over any file and line information" do
         source = Puppet::Type.type(:file).new :path => path
         source.file = "/my/file"

data/spec/unit/util/logging_spec.rb

@@ -177,6 +177,75 @@ describe Puppet::Util::Logging do
     end
   end
 
+  describe "when sending a warn_once" do
+    before(:each) {
+      @logger.clear_deprecation_warnings
+    }
+    after(:each) {
+      # this is required because of bugs in Mocha whe tearing down expectations for each test
+      # why it works elsewhere is a mystery.
+      @logger.unstub(:warning)
+    }
+
+    it "warns with file when only file is given" do
+      @logger.expects(:warning).with(regexp_matches(/wet paint.*\(in aFile\)/m))
+      @logger.warn_once('kind', 'wp', "wet paint", 'aFile')
+    end
+
+    it "warns with unknown file and line when only line is given" do
+      @logger.expects(:warning).with(regexp_matches(/wet paint.*\(in unknown file, line 5\)/m))
+      @logger.warn_once('kind', 'wp', "wet paint", nil, 5)
+    end
+
+    it "warns with file and line when both are given" do
+      @logger.expects(:warning).with(regexp_matches(/wet paint.*\(at aFile:5\)/m))
+      @logger.warn_once('kind', 'wp', "wet paint",'aFile', 5)
+    end
+
+    it "warns once per key" do
+      @logger.expects(:warning).with(regexp_matches(/wet paint.*/m)).once
+      5.times do
+        @logger.warn_once('kind', 'wp', "wet paint")
+      end
+    end
+  end
+
+  describe "does not warn about undefined variables when disabled_warnings says so" do
+    let(:logger) { LoggingTester.new }
+
+    around(:each) do |example|
+      Puppet.settings.initialize_global_settings
+      logger.clear_deprecation_warnings
+      Puppet[:disable_warnings] = ['undefined_variables']
+      example.run
+      Puppet[:disable_warnings] = []
+      logger.unstub(:warning)
+    end
+
+    it "does not produce warning if kind is disabled" do
+      logger.expects(:warning).never
+      logger.warn_once('undefined_variables', 'wp', "wet paint")
+    end
+  end
+
+  describe "warns about undefined variables when deprecations are in disabled_warnings" do
+    let(:logger) { LoggingTester.new }
+
+    around(:each) do |example|
+      Puppet.settings.initialize_global_settings
+      logger.clear_deprecation_warnings
+      Puppet[:disable_warnings] = ['deprecations']
+      example.run
+      Puppet[:disable_warnings] = []
+      logger.unstub(:warning)
+    end
+
+    it "produces warning even if deprecation warnings are disabled " do
+      logger.expects(:warning).once
+      logger.warn_once('undefined_variables', 'wp', "wet paint")
+    end
+  end
+
   describe "when formatting exceptions" do
     it "should be able to format a chain of exceptions" do
       exc3 = Puppet::Error.new("original")

data/spec/unit/util/monkey_patches_spec.rb

@@ -5,10 +5,74 @@ require 'puppet/util/monkey_patches'
 
 
 describe Symbol do
+  after :all do
+    $unique_warnings.delete('symbol_comparison') if $unique_warnings
+  end
+
   it "should return self from #intern" do
     symbol = :foo
     expect(symbol).to equal symbol.intern
   end
+
+  describe "when :strict is off" do
+    before :each do
+      Puppet.settings[:strict] = :off
+    end
+
+    after :all do
+      Puppet.settings[:strict] = Puppet.settings.setting(:strict).default
+    end
+
+    it "should not warn if compared against another symbol" do
+      Puppet.expects(:warn_once).never
+      expect(:foo <=> :bar).to equal(1)
+    end
+
+    it "should not warn if compared against a non-symbol value" do
+      Puppet.expects(:warn_once).never
+      expect(:foo <=> "foo").to equal(0)
+    end
+  end
+
+  describe "when :strict is warning" do
+    before :each do
+      Puppet.settings[:strict] = :warning
+    end
+
+    after :all do
+      Puppet.settings[:strict] = Puppet.settings.setting(:strict).default
+    end
+
+    it "should not warn if compared against another symbol" do
+      Puppet.expects(:warn_once).never
+      expect(:foo <=> :bar).to equal(1)
+    end
+
+    it "should warn if compared against a non-symbol value" do
+      Puppet.expects(:warn_once).once
+      expect(:foo <=> "foo").to equal(0)
+    end
+  end
+
+  describe "when :strict is error" do
+    before :each do
+      Puppet.settings[:strict] = :error
+    end
+
+    after :all do
+      Puppet.settings[:strict] = Puppet.settings.setting(:strict).default
+    end
+
+    it "should not raise if compared against another symbol" do
+      Puppet.expects(:warn_once).never
+      expect(:foo <=> :bar).to equal(1)
+    end
+
+    it "should raise if compared against a non-symbol value" do
+      Puppet.expects(:warn_once).never
+      expect { :foo <=> "foo" }.to raise_error(ArgumentError, "Comparing Symbols to non-Symbol values is no longer allowed")
+    end
+  end
 end
 
 describe IO do
@@ -173,8 +237,9 @@ end
 
 
 describe OpenSSL::X509::Store, :if => Puppet::Util::Platform.windows? do
-  let(:store) { described_class.new }
-  let(:cert)  { OpenSSL::X509::Certificate.new(File.read(my_fixture('x509.pem'))) }
+  let(:store)    { described_class.new }
+  let(:cert)     { OpenSSL::X509::Certificate.new(File.read(my_fixture('x509.pem'))) }
+  let(:samecert) { cert.dup() }
 
   def with_root_certs(certs)
     Puppet::Util::Windows::RootCerts.expects(:instance).returns(certs)
@@ -186,10 +251,21 @@ describe OpenSSL::X509::Store, :if => Puppet::Util::Platform.windows? do
     store.set_default_paths
   end
 
+  it "doesn't warn when calling set_default_paths multiple times" do
+    with_root_certs([cert])
+    store.expects(:warn).never
+
+    store.set_default_paths
+    store.set_default_paths
+  end
+
   it "ignores duplicate root certs" do
-    with_root_certs([cert, cert])
+    # prove that even though certs have identical contents, their hashes differ
+    expect(cert.hash).to_not eq(samecert.hash)
+    with_root_certs([cert, samecert])
 
     store.expects(:add_cert).with(cert).once
+    store.expects(:add_cert).with(samecert).never
 
     store.set_default_paths
   end

data/spec/unit/util/multi_match_spec.rb

@@ -0,0 +1,39 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/util/multi_match'
+
+describe "The Puppet::Util::MultiMatch" do
+  let(:not_nil) { Puppet::Util::MultiMatch::NOT_NIL }
+  let(:mm) { Puppet::Util::MultiMatch }
+
+  it "matches against not nil" do
+    expect(not_nil === 3).to be(true)
+  end
+
+  it "matches against multiple values" do
+    expect(mm.new(not_nil, not_nil) === [3, 3]).to be(true)
+  end
+
+  it "matches each value using ===" do
+    expect(mm.new(3, 3.14) === [Integer, Float]).to be(true)
+  end
+
+  it "matches are commutative" do
+    expect(mm.new(3, 3.14) === mm.new(Integer, Float)).to be(true)
+    expect(mm.new(Integer, Float) === mm.new(3, 3.14)).to be(true)
+  end
+
+  it "has TUPLE constant for match of array of two non nil values" do
+    expect(mm::TUPLE === [3, 3]).to be(true)
+  end
+
+  it "has TRIPLE constant for match of array of two non nil values" do
+    expect(mm::TRIPLE === [3, 3, 3]).to be(true)
+  end
+
+  it "considers length of array of values when matching" do
+    expect(mm.new(not_nil, not_nil) === [6, 6, 6]).to be(false)
+    expect(mm.new(not_nil, not_nil) === [6]).to be(false)
+  end
+
+end