puppet 5.5.3-x64-mingw32 → 5.5.6-x64-mingw32

data/spec/integration/util/windows/security_spec.rb

@@ -224,7 +224,58 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
             end
           end
 
-          it "should round-trip all 128 modes that do not require deny ACEs" do
+          it "should round-trip all 128 modes that do not require deny ACEs, where owner and group are different" do
+            # windows defaults set Administrators, None when Administrator
+            # or Administrators, SYSTEM when System
+            # but we can guarantee group is different by explicitly setting to Users
+            winsec.set_group(sids[:users], path)
+
+            0.upto(1).each do |s|
+              0.upto(7).each do |u|
+                0.upto(u).each do |g|
+                  0.upto(g).each do |o|
+                    # if user is superset of group, and group superset of other, then
+                    # no deny ace is required, and mode can be converted to win32
+                    # access mask, and back to mode without loss of information
+                    # (provided the owner and group are not the same)
+                    next if ((u & g) != g) or ((g & o) != o)
+
+                    mode = (s << 9 | u << 6 | g << 3 | o << 0)
+                    winsec.set_mode(mode, path)
+                    expect(winsec.get_mode(path).to_s(8)).to eq(mode.to_s(8))
+                  end
+                end
+              end
+            end
+          end
+
+          it "should round-trip all 54 modes that do not require deny ACEs, where owner and group are same" do
+            winsec.set_group(winsec.get_owner(path), path)
+
+            0.upto(1).each do |s|
+              0.upto(7).each do |ug|
+                0.upto(ug).each do |o|
+                  # if user and group superset of other, then
+                  # no deny ace is required, and mode can be converted to win32
+                  # access mask, and back to mode without loss of information
+                  # (provided the owner and group are the same)
+                  next if ((ug & o) != o)
+                  mode = (s << 9 | ug << 6 | ug << 3 | o << 0)
+                  winsec.set_mode(mode, path)
+                  expect(winsec.get_mode(path).to_s(8)).to eq(mode.to_s(8))
+                end
+              end
+            end
+          end
+
+          # The SYSTEM user is a special case therefore we need to test that we round trip correctly when set
+          it "should round-trip all 128 modes that do not require deny ACEs, when simulating a SYSTEM service" do
+            # The owner and group for files/dirs created, when running as a service under Local System are
+            # Owner = Administrators
+            # Group = SYSTEM
+            winsec.set_owner(sids[:administrators], path)
+            winsec.set_group(sids[:system], path)
+
             0.upto(1).each do |s|
               0.upto(7).each do |u|
                 0.upto(u).each do |g|
@@ -566,6 +617,32 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
           # end
         end
 
+        describe "#mode=" do
+          # setting owner to SYSTEM requires root
+          it "should round-trip all 54 modes that do not require deny ACEs, when simulating a SYSTEM scheduled task" do
+            # The owner and group for files/dirs created, when running as a Scheduled Task as Local System are
+            # Owner = SYSTEM
+            # Group = SYSTEM
+            winsec.set_group(sids[:system], path)
+            winsec.set_owner(sids[:system], path)
+
+            0.upto(1).each do |s|
+              0.upto(7).each do |ug|
+                0.upto(ug).each do |o|
+                  # if user and group superset of other, then
+                  # no deny ace is required, and mode can be converted to win32
+                  # access mask, and back to mode without loss of information
+                  # (provided the owner and group are the same)
+                  next if ((ug & o) != o)
+                  mode = (s << 9 | ug << 6 | ug << 3 | o << 0)
+                  winsec.set_mode(mode, path)
+                  expect(winsec.get_mode(path).to_s(8)).to eq(mode.to_s(8))
+                end
+              end
+            end
+          end
+        end
+
         describe "when the parent directory" do
           before :each do
             winsec.set_owner(sids[:current_user], parent)

data/spec/unit/application/master_spec.rb

@@ -7,6 +7,7 @@ require 'puppet/network/server'
 
 describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windows? do
   before :each do
+    Puppet[:bindaddress] = '127.0.0.1'
     @master = Puppet::Application[:master]
     @daemon = stub_everything 'daemon'
     Puppet::Daemon.stubs(:new).returns(@daemon)
@@ -357,6 +358,7 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
 
       it "should log a deprecation notice when running a WEBrick server" do
         Puppet.expects(:deprecation_warning).with("The WEBrick Puppet master server is deprecated and will be removed in a future release. Please use Puppet Server instead. See http://links.puppet.com/deprecate-rack-webrick-servers for more information.")
+        Puppet.expects(:deprecation_warning).with("Accessing 'bindaddress' as a setting is deprecated.")
 
         @master.main
       end

data/spec/unit/configurer/downloader_spec.rb

@@ -160,6 +160,11 @@ describe Puppet::Configurer::Downloader do
       expect(@dler.catalog.host_config).to eq(false)
     end
 
+    it "should not issue a deprecation warning for source_permissions" do
+      Puppet.expects(:puppet_deprecation_warning).never
+      catalog = @dler.catalog
+      expect(catalog.resources.size).to eq(1) # Must consume catalog to fix warnings
+    end
   end
 
   describe "when downloading" do

data/spec/unit/defaults_spec.rb

@@ -124,6 +124,19 @@ describe "Defaults" do
     end
   end
 
+  describe 'manage_internal_file_permissions' do
+    describe 'on windows', :if => Puppet::Util::Platform.windows? do
+      it 'should default to false' do
+        expect(Puppet.settings[:manage_internal_file_permissions]).to be false
+      end
+    end
+    describe 'on non-windows', :if => ! Puppet::Util::Platform.windows? do
+      it 'should default to true' do
+        expect(Puppet.settings[:manage_internal_file_permissions]).to be true
+      end
+    end
+  end
+
   describe 'basemodulepath' do
     it 'includes the global and system modules on non-windows', :unless => Puppet::Util::Platform.windows? do
       expect(

data/spec/unit/face/help_spec.rb

@@ -127,7 +127,8 @@ describe Puppet::Face[:help, '0.0.1'] do
         expect(subject).to match(%r{ #{appname} })
 
         summary = Puppet::Face[:help, :current].horribly_extract_summary_from(appname)
-        summary and expect(subject).to match(%r{ #{summary}\b})
+        summary_regex = Regexp.escape(summary)
+        summary and expect(subject).to match(%r{ #{summary_regex}$})
       end
     end
   end

data/spec/unit/indirector/ldap_spec.rb

@@ -13,12 +13,33 @@ describe Puppet::Indirector::Ldap do
     end
 
     @connection = mock 'ldap'
+  end
+
+  describe "when instantiating ldap" do
+    it "should be deprecated" do
+      Puppet.expects(:deprecation_warning).with("Puppet::Indirector::Ldap is deprecated and will be removed in a future release of Puppet.")
+
+      @ldap_class.new
+    end
+
+    it "should not emit a deprecation warning when they are disabled" do
+      Puppet.expects(:warning).with(regexp_matches(/Puppet::Indirector::Ldap is deprecated/)).never
+      Puppet[:disable_warnings] = ['deprecations']
 
-    @searcher = @ldap_class.new
+      @ldap_class.new
+    end
+
+    it "should only emit the deprecation warning once" do
+      Puppet.expects(:warning).with(regexp_matches(/Puppet::Indirector::Ldap is deprecated/)).once
+
+      @ldap_class.new
+      @ldap_class.new
+    end
   end
 
   describe "when searching ldap" do
     before do
+      @searcher = @ldap_class.new
       # Stub everything, and we can selectively replace with an expect as
       # we need to for testing.
       @searcher.stubs(:connection).returns(@connection)

data/spec/unit/node/environment_spec.rb

@@ -507,6 +507,20 @@ describe Puppet::Node::Environment do
       Puppet::GettextConfig.expects(:use_text_domain).with(env.name)
       env.with_text_domain do; end
     end
+
+    it "yields block results" do
+      ran = false
+      expect(env.with_text_domain { ran = true; :result }).to eq(:result)
+      expect(ran).to eq(true)
+    end
+
+    it "yields block results when i18n is disabled" do
+      Puppet[:disable_i18n] = true
+
+      ran = false
+      expect(env.with_text_domain { ran = true; :result }).to eq(:result)
+      expect(ran).to eq(true)
+    end
   end
 
 end

data/spec/unit/parser/functions/tagged_spec.rb

@@ -22,4 +22,20 @@ describe "the 'tagged' function" do
       @scope.function_tagged(['one', 'two'])
     end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
   end
+
+  it 'should be case-insensitive' do
+    resource = Puppet::Parser::Resource.new(:file, "/file", :scope => @scope)
+    @scope.stubs(:resource).returns resource
+    @scope.function_tag ["one"]
+
+    expect(@scope.function_tagged(['One'])).to eq(true)
+  end
+
+  it 'should check if all specified tags are included' do
+    resource = Puppet::Parser::Resource.new(:file, "/file", :scope => @scope)
+    @scope.stubs(:resource).returns resource
+    @scope.function_tag ["one"]
+
+    expect(@scope.function_tagged(['one', 'two'])).to eq(false)
+  end
 end

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

@@ -10,12 +10,25 @@ describe "validating 4x" do
 
   let(:acceptor) { Puppet::Pops::Validation::Acceptor.new() }
   let(:validator) { Puppet::Pops::Validation::ValidatorFactory_4_0.new().validator(acceptor) }
+  let(:environment) { Puppet::Node::Environment.create(:bar, ['path']) }
 
   def validate(factory)
     validator.validate(factory.model)
     acceptor
   end
 
+  def deprecation_count(acceptor)
+    acceptor.diagnostics.select {|d| d.severity == :deprecation }.count
+  end
+
+  def with_environment(environment, env_params = {})
+    override_env = environment
+    override_env = environment.override_with(env_params) if env_params.count > 0
+    Puppet.override(current_environment: override_env) do
+      yield
+    end
+  end
+
   it 'should raise error for illegal class names' do
     expect(validate(parse('class aaa::_bbb {}'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_NAME)
     expect(validate(parse('class Aaa {}'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_NAME)
@@ -34,6 +47,72 @@ describe "validating 4x" do
     expect(validate(parse('function ::aaa() {}'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_NAME)
   end
 
+  it 'should raise error for illegal definition locations' do
+    with_environment(environment) do
+      expect(validate(parse('function aaa::ccc() {}', 'path/aaa/manifests/bbb.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('class bbb() {}', 'path/aaa/manifests/init.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('define aaa::bbb::ccc::eee() {}', 'path/aaa/manifests/bbb/ddd.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
+  it 'should not raise error for legal definition locations' do
+    with_environment(environment) do
+      expect(validate(parse('function aaa::bbb() {}',      'path/aaa/manifests/bbb.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('class aaa() {}',      'path/aaa/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('function aaa::bbB::ccc() {}', 'path/aaa/manifests/bBb.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('function aaa::bbb::ccc() {}', 'path/aaa/manifests/bbb/CCC.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
+  it 'should not raise error for class locations when not parsing a file' do
+    #nil/'' file means eval or some other way to get puppet language source code into the catalog
+    with_environment(environment) do
+      expect(validate(parse('function aaa::ccc() {}', nil))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('function aaa::ccc() {}', ''))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
+  it 'should not raise error for legal definition locations' do
+    with_environment(environment, :manifest => 'a/manifest/file.pp') do
+      expect(validate(parse('function aaa::bbb() {}',      'path/aaa/manifests/bbb.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('class aaa() {}',      'path/aaa/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('function aaa::bbB::ccc() {}', 'path/aaa/manifests/bBb.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('function aaa::bbb::ccc() {}', 'path/aaa/manifests/bbb/CCC.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
+  it 'should not raise error for definitions inside initial --manifest file' do
+    with_environment(environment, :manifest => 'a/manifest/file.pp') do
+      expect(validate(parse('class aaa() {}', 'a/manifest/file.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
+  it 'should not raise error for definitions inside initial --manifest directory' do
+    with_environment(environment, :manifest => 'a/manifest/dir') do
+      expect(validate(parse('class aaa() {}', 'a/manifest/dir/file1.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('class bbb::ccc::ddd() {}', 'a/manifest/dir/and/more/stuff.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
+  it 'should not raise error for definitions not inside initial --manifest but also not in modulepath' do
+    with_environment(environment, :manifest => 'a/manifest/somewhere/else') do
+      expect(validate(parse('class aaa() {}', 'a/random/dir/file1.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
+  it 'should raise error if the file is in the modulepath but is not well formed' do
+    with_environment(environment) do
+      expect(validate(parse('class aaa::bbb::ccc() {}', 'path/manifest/aaa/bbb.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      expect(validate(parse('class aaa::bbb::ccc() {}', 'path/aaa/bbb/manifest/ccc.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
+  it 'should not raise error for definitions not inside initial --manifest but also not in modulepath because of only a case difference' do
+    with_environment(environment) do
+        expect(validate(parse('class aaa::bb() {}', 'Path/aaa/manifests/ccc.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
   it 'should raise error for illegal type names' do
     expect(validate(parse('type ::Aaa = Any'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_NAME)
   end
@@ -56,6 +135,16 @@ describe "validating 4x" do
       expect(acceptor.error_count).to eql(0)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
+
+    it 'produces a deprecation for illegal function locations' do
+      with_environment(environment) do
+        acceptor = validate(parse('function aaa::ccc() {}', 'path/aaa/manifests/bbb.pp'))
+        expect(deprecation_count(acceptor)).to eql(1)
+        expect(acceptor.warning_count).to eql(1)
+        expect(acceptor.error_count).to eql(0)
+        expect(acceptor).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      end
+    end
   end
 
   context 'with --strict set to warning' do
@@ -74,12 +163,22 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
-    it 'produces a  warning for exported class resource' do
+    it 'produces a warning for exported class resource' do
       acceptor = validate(parse('@@class { test: }'))
       expect(acceptor.warning_count).to eql(1)
       expect(acceptor.error_count).to eql(0)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
+
+    it 'produces a deprecation for illegal function locations' do
+      with_environment(environment) do
+        acceptor = validate(parse('function aaa::ccc() {}', 'path/aaa/manifests/bbb.pp'))
+        expect(deprecation_count(acceptor)).to eql(1)
+        expect(acceptor.warning_count).to eql(1)
+        expect(acceptor.error_count).to eql(0)
+        expect(acceptor).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      end
+    end
   end
 
   context 'with --strict set to error' do
@@ -111,6 +210,16 @@ describe "validating 4x" do
       expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
+
+    it 'produces a deprecation for illegal function locations' do
+      with_environment(environment) do
+        acceptor = validate(parse('function aaa::ccc() {}', 'path/aaa/manifests/bbb.pp'))
+        expect(deprecation_count(acceptor)).to eql(1)
+        expect(acceptor.warning_count).to eql(1)
+        expect(acceptor.error_count).to eql(0)
+        expect(acceptor).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      end
+    end
   end
 
   context 'with --strict set to off' do
@@ -121,6 +230,16 @@ describe "validating 4x" do
       expect(acceptor.error_count).to eql(0)
       expect(acceptor).to_not have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
+
+    it 'produces a deprecation for illegal function locations' do
+      with_environment(environment) do
+        acceptor = validate(parse('function aaa::ccc() {}', 'path/aaa/manifests/bbb.pp'))
+        expect(deprecation_count(acceptor)).to eql(1)
+        expect(acceptor.warning_count).to eql(1)
+        expect(acceptor.error_count).to eql(0)
+        expect(acceptor).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      end
+    end
   end
 
   context 'irrespective of --strict' do
@@ -145,7 +264,7 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
-    it 'produces a  warning for exported class resource' do
+    it 'produces a warning for exported class resource' do
       acceptor = validate(parse('@@class { test: }'))
       expect(acceptor.warning_count).to eql(1)
       expect(acceptor.error_count).to eql(0)
@@ -156,6 +275,22 @@ describe "validating 4x" do
   context 'with --tasks set' do
     before(:each) { Puppet[:tasks] = true }
 
+    it 'raises an error for illegal plan names' do
+      with_environment(environment) do
+        expect(validate(parse('plan aaa::ccc::eee() {}', 'path/aaa/plans/bbb/ccc/eee.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+        expect(validate(parse('plan aaa() {}', 'path/aaa/plans/aaa.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+        expect(validate(parse('plan aaa::bbb() {}', 'path/aaa/plans/bbb/bbb.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      end
+    end
+
+    it 'accepts legal plan names' do
+      with_environment(environment) do
+        expect(validate(parse('plan aaa::ccc::eee() {}', 'path/aaa/plans/ccc/eee.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+        expect(validate(parse('plan aaa() {}', 'path/aaa/plans/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+        expect(validate(parse('plan aaa::bbb() {}', 'path/aaa/plans/bbb.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+      end
+    end
+
     it 'produces an error for application' do
       acceptor = validate(parse('application test {}'))
       expect(acceptor.error_count).to eql(1)
@@ -662,7 +797,7 @@ describe "validating 4x" do
     end
   end
 
-  def parse(source)
-    Puppet::Pops::Parser::Parser.new.parse_string(source)
+  def parse(source, path=nil)
+    Puppet::Pops::Parser::Parser.new.parse_string(source, path)
   end
 end

data/spec/unit/provider/augeas/augeas_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/util/package'
 
@@ -235,6 +234,50 @@ describe provider_class do
       expect(@provider.process_values(command)).to eq(true)
     end
 
+    it "should return true for an array match with double quotes and spaces" do
+      command = ["values", "fake value", "==   [  \"set\"  ,  \"of\" , \"values\"  ]  "]
+      expect(@provider.process_values(command)).to eq(true)
+    end
+
+    it "should return true for an array match with internally escaped single quotes" do
+      @provider.aug.stubs(:match).returns(["set", "o'values", "here"])
+      @provider.aug.stubs(:get).returns('set').then.returns("o'values").then.returns('here')
+      command = ["values", "fake value", "== [ 'set', 'o\\'values', 'here']"]
+      expect(@provider.process_values(command)).to eq(true)
+    end
+
+    it "should return true for an array match with octal character sequences" do
+      command = ["values", "fake value", "== [\"\\x73et\", \"of\", \"values\"]"]
+      expect(@provider.process_values(command)).to eq(true)
+    end
+
+    it "should return true for an array match with hex character sequences" do
+      command = ["values", "fake value", "== [\"\\163et\", \"of\", \"values\"]"]
+      expect(@provider.process_values(command)).to eq(true)
+    end
+
+    it "should return true for an array match with short unicode escape sequences" do
+      command = ["values", "fake value", "== [\"\\u0073et\", \"of\", \"values\"]"]
+      expect(@provider.process_values(command)).to eq(true)
+    end
+
+    it "should return true for an array match with single character long unicode escape sequences" do
+      command = ["values", "fake value", "== [\"\\u{0073}et\", \"of\", \"values\"]"]
+      expect(@provider.process_values(command)).to eq(true)
+    end
+
+    it "should return true for an array match with multi-character long unicode escape sequences" do
+      command = ["values", "fake value", "== [\"\\u{0073 0065 0074}\", \"of\", \"values\"]"]
+      expect(@provider.process_values(command)).to eq(true)
+    end
+
+    it "should return true for an array match with literal backslashes" do
+      @provider.aug.stubs(:match).returns(["set", "o\\values", "here"])
+      @provider.aug.stubs(:get).returns('set').then.returns("o\\values").then.returns('here')
+      command = ["values", "fake value", "== [ 'set', 'o\\\\values', 'here']"]
+      expect(@provider.process_values(command)).to eq(true)
+    end
+
     it "should return false for an array non match" do
       command = ["values", "fake value", "== ['this', 'should', 'not', 'match']"]
       expect(@provider.process_values(command)).to eq(false)
@@ -249,6 +292,18 @@ describe provider_class do
       command = ["values", "fake value", "!= ['this', 'should', 'not', 'match']"]
       expect(@provider.process_values(command)).to eq(true)
     end
+
+    it "should return true for an array non match with double quotes and spaces" do
+      command = ["values", "fake value", "!=   [  \"this\"  ,  \"should\" ,\"not\",  \"match\"  ]  "]
+      expect(@provider.process_values(command)).to eq(true)
+    end
+
+    it "should return true for an empty array match" do
+      @provider.aug.stubs(:match).returns([])
+      @provider.aug.stubs(:get)
+      command = ["values", "fake value", "== []"]
+      expect(@provider.process_values(command)).to eq(true)
+    end
   end
 
   describe "match filters" do
@@ -294,6 +349,11 @@ describe provider_class do
       expect(@provider.process_match(command)).to eq(true)
     end
 
+    it "should return true for an array match with double quotes and spaces" do
+      command = ["match", "fake value", "==   [  \"set\"  ,  \"of\" , \"values\"  ]  "]
+      expect(@provider.process_match(command)).to eq(true)
+    end
+
     it "should return false for an array non match" do
       command = ["match", "fake value", "== ['this', 'should', 'not', 'match']"]
       expect(@provider.process_match(command)).to eq(false)
@@ -308,6 +368,11 @@ describe provider_class do
       command = ["match", "fake value", "!= ['this', 'should', 'not', 'match']"]
       expect(@provider.process_match(command)).to eq(true)
     end
+
+    it "should return true for an array non match with double quotes and spaces" do
+      command = ["match", "fake value", "!=   [  \"this\"  ,  \"should\" ,\"not\",  \"match\"  ]  "]
+      expect(@provider.process_match(command)).to eq(true)
+    end
   end
 
   describe "need to run" do

data/spec/unit/provider/service/smf_spec.rb

@@ -18,8 +18,6 @@ describe provider_class, :if => Puppet.features.posix? do
 
     FileTest.stubs(:file?).with('/usr/sbin/svcadm').returns true
     FileTest.stubs(:executable?).with('/usr/sbin/svcadm').returns true
-    FileTest.stubs(:file?).with('/usr/sbin/svccfg').returns true
-    FileTest.stubs(:executable?).with('/usr/sbin/svccfg').returns true
     FileTest.stubs(:file?).with('/usr/bin/svcs').returns true
     FileTest.stubs(:executable?).with('/usr/bin/svcs').returns true
     Facter.stubs(:value).with(:operatingsystem).returns('Solaris')
@@ -76,9 +74,9 @@ describe provider_class, :if => Puppet.features.posix? do
       @provider.expects(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").returns("online\t-")
       @provider.status
     end
-    it "should return absent if svcs can't find the service" do
+    it "should return stopped if svcs can't find the service" do
       @provider.stubs(:svcs).raises(Puppet::ExecutionFailure.new("no svc found"))
-      expect(@provider.status).to eq(:absent)
+      expect(@provider.status).to eq(:stopped)
     end
     it "should return running if online in svcs output" do
       @provider.stubs(:svcs).returns("online\t-")
@@ -168,14 +166,12 @@ describe provider_class, :if => Puppet.features.posix? do
 
   describe "when stopping" do
     it "should execute external command 'svcadm disable /system/myservice'" do
-      @provider.stubs(:status).returns :running
       @provider.expects(:texecute).with(:stop, ["/usr/sbin/svcadm", :disable, '-s', "/system/myservice"], true)
       @provider.expects(:wait).with('offline', 'disabled', 'uninitialized')
       @provider.stop
     end
 
     it "should error if timeout occurs while stopping the service" do
-      @provider.stubs(:status).returns :running
       @provider.expects(:texecute).with(:stop, ["/usr/sbin/svcadm", :disable, '-s', "/system/myservice"], true)
       Timeout.expects(:timeout).with(60).raises(Timeout::Error)
       expect { @provider.stop }.to raise_error Puppet::Error, ('Timed out waiting for /system/myservice to transition states')

data/spec/unit/provider/service/upstart_spec.rb

@@ -34,6 +34,43 @@ describe Puppet::Type.type(:service).provider(:upstart) do
     expect(described_class.default?).to be_truthy
   end
 
+  context "upstart daemon existence confine" do
+    # We have a separate method here because our search for the upstart daemon
+    # confine expects it to be the last confine declared in the upstart provider.
+    # If in the future we add other confines below it or change its order, these
+    # unit tests will fail. Placing knowledge of where this confine is located
+    # in one place makes updating it less painful in case we ever need to do this.
+    def assert_upstart_daemon_existence_confine_is(expected_value)
+      upstart_daemon_existence_confine = provider_class.confine_collection.instance_variable_get(:@confines)[-1]
+      expect(upstart_daemon_existence_confine.valid?).to be(expected_value)
+    end
+
+    let(:initctl_version) { ['/sbin/initctl', 'version', '--quiet'] }
+    before(:each) do
+      # Stub out /sbin/initctl
+      Puppet::Util.stubs(:which).with('/sbin/initctl').returns('/sbin/initctl')
+
+      # Both of our tests are asserting the confine :true block that shells out to
+      # `initctl version --quiet`. Its expression is evaluated at provider load-time.
+      # Hence before each test, we want to reload the upstart provider so that the
+      # confine is re-evaluated.
+      Puppet::Type.type(:service).unprovide(:upstart)
+    end
+
+    it "should return true when the daemon is running" do
+      Puppet::Util::Execution.expects(:execute).with(initctl_version, instance_of(Hash))
+      assert_upstart_daemon_existence_confine_is(true)
+    end
+
+    it "should return false when the daemon is not running" do
+      Puppet::Util::Execution.expects(:execute)
+        .with(initctl_version, instance_of(Hash))
+        .raises(Puppet::ExecutionFailure, "initctl failed!")
+
+      assert_upstart_daemon_existence_confine_is(false)
+    end
+  end
+
   describe "excluding services" do
     it "ignores tty and serial on Redhat systems" do
       Facter.stubs(:value).with(:osfamily).returns('RedHat')

data/spec/unit/settings/autosign_setting_spec.rb

@@ -72,11 +72,11 @@ describe Puppet::Settings::AutosignSetting do
   end
 
   describe "converting the setting to a resource" do
-    it "converts the file path to a file resource" do
+    it "converts the file path to a file resource", :if => !Puppet::Util::Platform.windows? do
       path = File.expand_path('/path/to/autosign.conf')
       settings.stubs(:value).with('autosign', nil, false).returns(path)
       Puppet::FileSystem.stubs(:exist?).with(path).returns true
-      Puppet.stubs(:features).returns(stub(:root? => true, :microsoft_windows? => false))
+      Puppet.features.expects(:root?).returns(true)
 
       setting.mode = '0664'
       setting.owner = 'service'