puppet 3.7.0-x64-mingw32 → 3.7.1-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31e1bd2dc3524fc2851ba297b11dfb40a38c7edd
-  data.tar.gz: 9c4b8ed1338bd7f99224c6f6799da462f0c57cc2
+  metadata.gz: ae8f1628aeefdddebcbf7a3f486e673ce84da9cf
+  data.tar.gz: eb3456b5ef08147602b4fc5563bb014c1cdf58e0
 SHA512:
-  metadata.gz: 56e752b5f2907ee6fa99efce384183b7960f18202b772c66853a7ccbcf0646aca33e356af785313d0e9df9a8e898afd9427c0d07abd610d1e9b1747e6af0e023
-  data.tar.gz: 426d2446f67dff5d44af74f22b1e985a9e182f8f25fde6ffafd47c9edbd0414fd0a83adc17484b8c8c42011b796580364d5ee06520601698015f07e21bd83668
+  metadata.gz: 5b68850ed5fe33f5f4b7fd5b901a1499b8aef22ba96728b2804187f2aa7defeb73acb85283b24da3f844ae618eb24e223a59a3d2f7bb123ac59ee4f0004bf197
+  data.tar.gz: e8af71206f85fbf45f5f7da2a92affe1d84d2d9fe82e5a83e8511cc050c2f76158c681bfd868ede5c897a00ae3a2f938073098fdfc16da2794477cf4ec36cef0

data/Gemfile

@@ -23,7 +23,9 @@ platforms :ruby do
   #gem 'ruby-augeas', :group => :development
 end
 
-gem "puppet", :path => File.dirname(__FILE__), :require => false
+if !ENV['PUPPET_LOADED']
+  gem "puppet", :path => File.dirname(__FILE__), :require => false
+end
 gem "facter", *location_for(ENV['FACTER_LOCATION'] || ['> 1.6', '< 3'])
 gem "hiera", *location_for(ENV['HIERA_LOCATION'] || '~> 1.0')
 gem "rake", "10.1.1", :require => false

data/lib/puppet/defaults.rb

@@ -1056,13 +1056,6 @@ EOT
 
         In either case, the path can point to a single file or to a directory of
         manifests to be evaluated in alphabetical order.",
-      :hook       => proc do |value|
-        uninterpolated_value = self.value(true)
-        if uninterpolated_value =~ /\$environment/ || value =~ /\$environment/ then
-          raise(Puppet::Settings::ValidationError,
-                "You cannot interpolate '$environment' within the 'default_manifest' setting.")
-        end
-      end
     },
     :disable_per_environment_manifest => {
       :default    => false,

data/lib/puppet/module_tool/applications/unpacker.rb

@@ -46,7 +46,7 @@ module Puppet::ModuleTool
         tmpdirpath = Pathname.new tmpdir
 
         symlinks.each do |s|
-          Puppet.warning "Symlinks in modules are unsupported. Please investigate symlink #{s.relative_path_from tmpdirpath}->#{s.realpath.relative_path_from tmpdirpath}."
+          Puppet.warning "Symlinks in modules are unsupported. Please investigate symlink #{s.relative_path_from tmpdirpath}->#{Puppet::FileSystem.readlink(s)}."
         end
       end
 

data/lib/puppet/network/http/compression.rb

@@ -46,7 +46,11 @@ module Puppet::Network::HTTP::Compression
     end
 
     def add_accept_encoding(headers={})
-      headers['accept-encoding'] = 'gzip; q=1.0, deflate; q=1.0; identity' if Puppet.settings[:http_compression]
+      if Puppet.settings[:http_compression]
+        headers['accept-encoding'] = 'gzip; q=1.0, deflate; q=1.0; identity'
+      else
+        headers['accept-encoding'] = 'identity'
+      end
       headers
     end
 

data/lib/puppet/pops/loader/loader_paths.rb

@@ -75,7 +75,7 @@ module Puppet::Pops::Loader::LoaderPaths
   end
 
   class FunctionPath4x < RubySmartPath
-    FUNCTION_PATH_4X = File.join('lib', 'puppet', 'functions')
+    FUNCTION_PATH_4X = File.join('puppet', 'functions')
 
     def relative_path
       FUNCTION_PATH_4X

data/lib/puppet/pops/loader/module_loaders.rb

@@ -20,6 +20,28 @@
 # @api private
 #
 module Puppet::Pops::Loader::ModuleLoaders
+  def self.system_loader_from(parent_loader, loaders)
+    # Puppet system may be installed in a fixed location via RPM, installed as a Gem, via source etc.
+    # The only way to find this across the different ways puppet can be installed is
+    # to search up the path from this source file's __FILE__ location until it finds the base of
+    # puppet.
+    #
+    puppet_lib = File.join(File.dirname(__FILE__), '../../..')
+    Puppet::Pops::Loader::ModuleLoaders::FileBased.new(parent_loader,
+                                                       loaders,
+                                                       nil,
+                                                       puppet_lib,
+                                                       'puppet_system')
+  end
+
+  def self.module_loader_from(parent_loader, loaders, module_name, module_path)
+    Puppet::Pops::Loader::ModuleLoaders::FileBased.new(parent_loader,
+                                                       loaders,
+                                                       module_name,
+                                                       File.join(module_path, 'lib'),
+                                                       module_name)
+  end
+
   class AbstractPathBasedModuleLoader < Puppet::Pops::Loader::BaseLoader
 
     # The name of the module, or nil, if this is a global "component"
@@ -47,11 +69,6 @@ module Puppet::Pops::Loader::ModuleLoaders
     def initialize(parent_loader, loaders, module_name, path, loader_name)
       super parent_loader, loader_name
 
-      # Irrespective of the path referencing a directory or file, the path must exist.
-      unless Puppet::FileSystem.exist?(path)
-        raise ArgumentError, "The given path '#{path}' does not exist!"
-      end
-
       @module_name = module_name
       @path = path
       @smart_paths = Puppet::Pops::Loader::LoaderPaths::SmartPaths.new(self)
@@ -178,9 +195,6 @@ module Puppet::Pops::Loader::ModuleLoaders
     #
     def initialize(parent_loader, loaders, module_name, path, loader_name)
       super
-      unless Puppet::FileSystem.directory?(path)
-        raise ArgumentError, "The given module root path '#{path}' is not a directory (required for file system based module path entry)"
-      end
       @path_index = Set.new()
     end
 

data/lib/puppet/pops/loaders.rb

@@ -64,16 +64,7 @@ class Puppet::Pops::Loaders
   private
 
   def create_puppet_system_loader()
-    module_name = nil
-    loader_name = 'puppet_system'
-
-    # Puppet system may be installed in a fixed location via RPM, installed as a Gem, via source etc.
-    # The only way to find this across the different ways puppet can be installed is
-    # to search up the path from this source file's __FILE__ location until it finds the parent of
-    # lib/puppet... e.g.. dirname(__FILE__)/../../..  (i.e. <somewhere>/lib/puppet/pops/loaders.rb).
-    #
-    puppet_lib = File.join(File.dirname(__FILE__), '../../..')
-    Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, self, module_name, puppet_lib, loader_name)
+    Puppet::Pops::Loader::ModuleLoaders.system_loader_from(static_loader, self)
   end
 
   def create_environment_loader(environment)
@@ -121,7 +112,7 @@ class Puppet::Pops::Loaders
       # Create data about this module
       md = LoaderModuleData.new(puppet_module)
       mr[puppet_module.name] = md
-      md.public_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(parent_loader, self, md.name, md.path, md.name)
+      md.public_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(parent_loader, self, md.name, md.path)
     end
     # NOTE: Do not resolve all modules here - this is wasteful if only a subset of modules / functions are used
     #       The resolution is triggered by asking for a module's private loader, since this means there is interest

data/lib/puppet/provider/service/windows.rb

@@ -21,21 +21,21 @@ Puppet::Type.type(:service).provide :windows, :parent => :service do
   def enable
     w32ss = Win32::Service.configure( 'service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_AUTO_START )
     raise Puppet::Error.new("Win32 service enable of #{@resource[:name]} failed" ) if( w32ss.nil? )
-  rescue Win32::Service::Error => detail
+  rescue => detail
     raise Puppet::Error.new("Cannot enable #{@resource[:name]}, error was: #{detail}", detail )
   end
 
   def disable
     w32ss = Win32::Service.configure( 'service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_DISABLED )
     raise Puppet::Error.new("Win32 service disable of #{@resource[:name]} failed" ) if( w32ss.nil? )
-  rescue Win32::Service::Error => detail
+  rescue => detail
     raise Puppet::Error.new("Cannot disable #{@resource[:name]}, error was: #{detail}", detail )
   end
 
   def manual_start
     w32ss = Win32::Service.configure( 'service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_DEMAND_START )
     raise Puppet::Error.new("Win32 service manual enable of #{@resource[:name]} failed" ) if( w32ss.nil? )
-  rescue Win32::Service::Error => detail
+  rescue => detail
     raise Puppet::Error.new("Cannot enable #{@resource[:name]} for manual start, error was: #{detail}", detail )
   end
 
@@ -55,7 +55,7 @@ Puppet::Type.type(:service).provide :windows, :parent => :service do
       else
         raise Puppet::Error.new("Unknown start type: #{w32ss.start_type}")
     end
-  rescue Win32::Service::Error => detail
+  rescue => detail
     raise Puppet::Error.new("Cannot get start type for #{@resource[:name]}, error was: #{detail}", detail )
   end
 
@@ -95,7 +95,7 @@ Puppet::Type.type(:service).provide :windows, :parent => :service do
     end
     debug("Service #{@resource[:name]} is #{w32ss.current_state}")
     return state
-  rescue Win32::Service::Error => detail
+  rescue => detail
     raise Puppet::Error.new("Cannot get status of #{@resource[:name]}, error was: #{detail}", detail )
   end
 

data/lib/puppet/resource.rb

@@ -551,10 +551,12 @@ class Puppet::Resource
   end
 
   def extract_type_and_title(argtype, argtitle)
-    if    (argtitle || argtype) =~ /^([^\[\]]+)\[(.+)\]$/m then [ $1,                 $2            ]
-    elsif argtitle                                         then [ argtype,            argtitle      ]
-    elsif argtype.is_a?(Puppet::Type)                      then [ argtype.class.name, argtype.title ]
-    elsif argtype.is_a?(Hash)                              then
+    if    (argtype.nil? || argtype == :component || argtype == :whit) &&
+           argtitle =~ /^([^\[\]]+)\[(.+)\]$/m                 then [ $1,                 $2            ]
+    elsif argtitle.nil? && argtype =~ /^([^\[\]]+)\[(.+)\]$/m  then [ $1,                 $2            ]
+    elsif argtitle                                             then [ argtype,            argtitle      ]
+    elsif argtype.is_a?(Puppet::Type)                          then [ argtype.class.name, argtype.title ]
+    elsif argtype.is_a?(Hash)                                  then
       raise ArgumentError, "Puppet::Resource.new does not take a hash as the first argument. "+
         "Did you mean (#{(argtype[:type] || argtype["type"]).inspect}, #{(argtype[:title] || argtype["title"]).inspect }) ?"
     else raise ArgumentError, "No title provided and #{argtype.inspect} is not a valid resource reference"

data/lib/puppet/settings.rb

@@ -887,8 +887,8 @@ class Puppet::Settings
     sections = nil if sections.empty?
 
     catalog = Puppet::Resource::Catalog.new("Settings", Puppet::Node::Environment::NONE)
-
     @config.keys.find_all { |key| @config[key].is_a?(FileSetting) }.each do |key|
+      next if (key == :manifestdir && should_skip_manifestdir?())
       file = @config[key]
       next unless (sections.nil? or sections.include?(file.section))
       next unless resource = file.to_resource
@@ -905,6 +905,13 @@ class Puppet::Settings
     catalog
   end
 
+  def should_skip_manifestdir?()
+    setting = @config[:environmentpath]
+    !(setting.nil? || setting.value.nil? || setting.value.empty?)
+  end
+
+  private :should_skip_manifestdir?
+
   # Convert our list of config settings into a configuration file.
   def to_config
     str = %{The configuration file for #{Puppet.run_mode.name}.  Note that this file
@@ -1130,11 +1137,13 @@ Generated on #{Time.now}.
     configured_environment = self[:environment]
     if configured_environment == "production" && envdir && Puppet::FileSystem.exist?(envdir)
       configured_environment_path = File.join(envdir, configured_environment)
-      catalog.add_resource(
-        Puppet::Resource.new(:file,
-                             configured_environment_path,
-                             :parameters => { :ensure => 'directory' })
-      )
+      if !Puppet::FileSystem.symlink?(configured_environment_path)
+        catalog.add_resource(
+          Puppet::Resource.new(:file,
+                               configured_environment_path,
+                               :parameters => { :ensure => 'directory' })
+        )
+      end
     end
   end
 
@@ -1232,6 +1241,7 @@ Generated on #{Time.now}.
   # @api public
   class ChainedValues
     ENVIRONMENT_SETTING = "environment".freeze
+    ENVIRONMENT_INTERPOLATION_ALLOWED = ['config_version'].freeze
 
     # @see Puppet::Settings.values
     # @api private
@@ -1280,7 +1290,7 @@ Generated on #{Time.now}.
         else
           # Convert it if necessary
           begin
-            val = convert(val)
+            val = convert(val, name)
           rescue InterpolationError => err
             # This happens because we don't have access to the param name when the
             # exception is originally raised, but we want it in the message
@@ -1296,27 +1306,45 @@ Generated on #{Time.now}.
 
     private
 
-    def convert(value)
+    def convert(value, setting_name)
       case value
       when nil
         nil
       when String
-        value.gsub(/\$(\w+)|\$\{(\w+)\}/) do |value|
+        failed_environment_interpolation = false
+        interpolated_value = value.gsub(/\$(\w+)|\$\{(\w+)\}/) do |expression|
           varname = $2 || $1
-          if varname == ENVIRONMENT_SETTING && @environment
-            @environment
-          elsif varname == "run_mode"
-            @mode
-          elsif !(pval = interpolate(varname.to_sym)).nil?
-            pval
+          interpolated_expression =
+          if varname != ENVIRONMENT_SETTING || ok_to_interpolate_environment(setting_name)
+            if varname == ENVIRONMENT_SETTING && @environment
+              @environment
+            elsif varname == "run_mode"
+              @mode
+            elsif !(pval = interpolate(varname.to_sym)).nil?
+              pval
+            else
+              raise InterpolationError, "Could not find value for #{expression}"
+            end
           else
-            raise InterpolationError, "Could not find value for #{value}"
+            failed_environment_interpolation = true
+            expression
           end
+          interpolated_expression
         end
+        if failed_environment_interpolation
+          Puppet.warning("You cannot interpolate $environment within '#{setting_name}' when using directory environments.  Its value will remain #{interpolated_value}.")
+        end
+        interpolated_value
       else
         value
       end
     end
+
+    def ok_to_interpolate_environment(setting_name)
+      return true if Puppet.settings.value(:environmentpath, nil, true).empty?
+
+      ENVIRONMENT_INTERPOLATION_ALLOWED.include?(setting_name.to_s)
+    end
   end
 
   class Values

data/lib/puppet/ssl/validator/default_validator.rb

@@ -11,6 +11,8 @@ class Puppet::SSL::Validator::DefaultValidator #< class Puppet::SSL::Validator
   attr_reader :verify_errors
   attr_reader :ssl_configuration
 
+  FIVE_MINUTES_AS_SECONDS = 5 * 60
+
   # Creates a new DefaultValidator, optionally with an SSL Configuration and SSL Host.
   #
   # @param ssl_configuration [Puppet::SSL::Configuration] (a default configuration) ssl_configuration the SSL configuration to use
@@ -52,7 +54,7 @@ class Puppet::SSL::Validator::DefaultValidator #< class Puppet::SSL::Validator
   # SSL_VERIFY_PEER flag is set. It must be supplied by the application and
   # receives two arguments: preverify_ok indicates, whether the verification of
   # the certificate in question was passed (preverify_ok=1) or not
-  # (preverify_ok=0). x509_ctx is a pointer to the complete context used for
+  # (preverify_ok=0). x509_store_ctx is a pointer to the complete context used for
   # the certificate chain verification.
   #
   # See {Puppet::Network::HTTP::Connection} for more information and where this
@@ -60,28 +62,47 @@ class Puppet::SSL::Validator::DefaultValidator #< class Puppet::SSL::Validator
   #
   # @param [Boolean] preverify_ok indicates whether the verification of the
   #   certificate in question was passed (preverify_ok=true)
-  # @param [OpenSSL::SSL::SSLContext] ssl_context holds the SSLContext for the
-  #   chain being verified.
+  # @param [OpenSSL::X509::StoreContext] store_context holds the X509 store context
+  #   for the chain being verified.
   #
   # @return [Boolean] false if the peer is invalid, true otherwise.
   #
   # @api private
   #
-  def call(preverify_ok, ssl_context)
-    # We must make a copy since the scope of the ssl_context will be lost
+  def call(preverify_ok, store_context)
+    # We must make a copy since the scope of the store_context will be lost
     # across invocations of this method.
-    current_cert = ssl_context.current_cert
-    @peer_certs << Puppet::SSL::Certificate.from_instance(current_cert)
-
     if preverify_ok
+      current_cert = store_context.current_cert
+      @peer_certs << Puppet::SSL::Certificate.from_instance(current_cert)
+
       # If we've copied all of the certs in the chain out of the SSL library
-      if @peer_certs.length == ssl_context.chain.length
+      if @peer_certs.length == store_context.chain.length
         # (#20027) The peer cert must be issued by a specific authority
         preverify_ok = valid_peer?
       end
     else
-      if ssl_context.error_string
-        @verify_errors << "#{ssl_context.error_string} for #{current_cert.subject}"
+      error = store_context.error || 0
+      error_string = store_context.error_string || "OpenSSL error #{error}"
+
+      case error
+      when OpenSSL::X509::V_ERR_CRL_NOT_YET_VALID
+        # current_crl can be nil
+        # https://github.com/ruby/ruby/blob/ruby_1_9_3/ext/openssl/ossl_x509store.c#L501-L510
+        crl = store_context.current_crl
+        if crl
+          if crl.last_update && crl.last_update < Time.now + FIVE_MINUTES_AS_SECONDS
+            Puppet.debug("Ignoring CRL not yet valid, current time #{Time.now.utc}, CRL last updated #{crl.last_update.utc}")
+            preverify_ok = true
+          else
+            @verify_errors << "#{error_string} for #{crl.issuer}"
+          end
+        else
+          @verify_errors << error_string
+        end
+      else
+        current_cert = store_context.current_cert
+        @verify_errors << "#{error_string} for #{current_cert.subject}"
       end
     end
     preverify_ok

data/lib/puppet/transaction.rb

@@ -105,6 +105,7 @@ class Puppet::Transaction
     overly_deferred_resource_handler = lambda do |resource|
       # We don't automatically assign unsuitable providers, so if there
       # is one, it must have been selected by the user.
+      return if missing_tags?(resource)
       if resource.provider
         resource.err "Provider #{resource.provider.class.name} is not functional on this host"
       else

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '3.7.0'
+  PUPPETVERSION = '3.7.1'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/integration/defaults_spec.rb

@@ -10,12 +10,6 @@ describe "Puppet defaults" do
     it "returns ./manifests by default" do
       expect(Puppet[:default_manifest]).to eq('./manifests')
     end
-
-    it "errors when $environment is part of the value" do
-      expect {
-        Puppet[:default_manifest] = '/$environment/manifest.pp'
-      }.to raise_error Puppet::Settings::ValidationError, /cannot interpolate.*\$environment/
-    end
   end
 
   describe "when disable_per_environment_manifest is set" do

data/spec/integration/environments/default_manifest_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 module EnvironmentsDefaultManifestsSpec
 describe "default manifests" do
-  FS = Puppet::FileSystem
 
   shared_examples_for "puppet with default_manifest settings" do
     let(:confdir) { Puppet[:confdir] }
@@ -113,16 +112,6 @@ describe "default manifests" do
         )
       end
 
-      it "raises an exception if default_manifest has $environment in it" do
-        File.open(File.join(confdir, "puppet.conf"), "w") do |f|
-          f.puts(<<-EOF)
-  environmentpath=#{environmentpath}
-  default_manifest=/foo/$environment
-          EOF
-        end
-
-        expect { Puppet.initialize_settings }.to raise_error(Puppet::Settings::ValidationError, /cannot interpolate.*\$environment.*in.*default_manifest/)
-      end
     end
 
     context "with disable_per_environment_manifest true" do

data/spec/integration/environments/settings_interpolation_spec.rb

@@ -0,0 +1,165 @@
+require 'pp'
+require 'spec_helper'
+
+module SettingsInterpolationSpec
+describe "interpolating $environment" do
+  let(:confdir) { Puppet[:confdir] }
+  let(:cmdline_args) { ['--confdir', confdir, '--vardir', Puppet[:vardir], '--hiera_config', Puppet[:hiera_config]] }
+
+  before(:each) do
+    FileUtils.mkdir_p(confdir)
+  end
+
+  shared_examples_for "a setting that does not interpolate $environment" do
+
+    before(:each) do
+      set_puppet_conf(confdir, <<-EOF)
+        environmentpath=$confdir/environments
+        #{setting}=#{value}
+      EOF
+    end
+
+    it "does not interpolate $environment" do
+      Puppet.initialize_settings(cmdline_args)
+      expect(Puppet[:environmentpath]).to eq("#{confdir}/environments")
+      expect(Puppet[setting.intern]).to eq(expected)
+    end
+
+    it "displays the interpolated value in the warning" do
+      Puppet.initialize_settings(cmdline_args)
+      Puppet[setting.intern]
+      expect(@logs).to have_matching_log(/cannot interpolate \$environment within '#{setting}'.*Its value will remain #{Regexp.escape(expected)}/)
+    end
+  end
+
+  context "when environmentpath is set" do
+
+    describe "config_version" do
+      it "interpolates $environment" do
+        envname = 'testing'
+        setting = 'config_version'
+        value = '/some/script $environment'
+        expected = "#{File.expand_path('/some/script')} testing"
+
+        set_puppet_conf(confdir, <<-EOF)
+          environmentpath=$confdir/environments
+          environment=#{envname}
+        EOF
+
+        set_environment_conf("#{confdir}/environments", envname, <<-EOF)
+          #{setting}=#{value}
+        EOF
+
+        Puppet.initialize_settings(cmdline_args)
+        expect(Puppet[:environmentpath]).to eq("#{confdir}/environments")
+        environment = Puppet.lookup(:environments).get(envname)
+        expect(environment.config_version).to eq(expected)
+        expect(@logs).to be_empty
+      end
+    end
+
+    describe "basemodulepath" do
+      let(:setting) { "basemodulepath" }
+      let(:value) { "$confdir/environments/$environment/modules:$confdir/environments/$environment/other_modules" }
+      let(:expected) { "#{confdir}/environments/$environment/modules:#{confdir}/environments/$environment/other_modules" }
+
+      it_behaves_like "a setting that does not interpolate $environment"
+
+      it "logs a single warning for multiple instaces of $environment in the setting" do
+        set_puppet_conf(confdir, <<-EOF)
+          environmentpath=$confdir/environments
+          #{setting}=#{value}
+        EOF
+
+        Puppet.initialize_settings(cmdline_args)
+        expect(@logs.map(&:to_s).grep(/cannot interpolate \$environment within '#{setting}'/).count).to eq(1)
+      end
+    end
+
+    describe "environment" do
+      let(:setting) { "environment" }
+      let(:value) { "whatareyouthinking$environment" }
+      let(:expected) { value }
+
+      it_behaves_like "a setting that does not interpolate $environment"
+    end
+
+    describe "the default_manifest" do
+      let(:setting) { "default_manifest" }
+      let(:value) { "$confdir/manifests/$environment" }
+      let(:expected) { "#{confdir}/manifests/$environment" }
+
+      it_behaves_like "a setting that does not interpolate $environment"
+    end
+
+    it "does not interpolate $environment and logs a warning when interpolating environmentpath" do
+      setting = 'environmentpath'
+      value = "$confdir/environments/$environment"
+      expected = "#{confdir}/environments/$environment"
+
+      set_puppet_conf(confdir, <<-EOF)
+        #{setting}=#{value}
+      EOF
+
+      Puppet.initialize_settings(cmdline_args)
+      expect(Puppet[setting.intern]).to eq(expected)
+      expect(@logs).to have_matching_log(/cannot interpolate \$environment within '#{setting}'/)
+    end
+  end
+
+  def assert_does_interpolate_environment(setting, value, expected_interpolation)
+    set_puppet_conf(confdir, <<-EOF)
+      #{setting}=#{value}
+    EOF
+
+    Puppet.initialize_settings(cmdline_args)
+    expect(Puppet[:environmentpath]).to be_empty
+    expect(Puppet[setting.intern]).to eq(expected_interpolation)
+    expect(@logs).to_not have_matching_log(/cannot interpolate \$environment within '#{setting}'/)
+  end
+
+  context "when environmentpath is not set" do
+    it "does interpolate $environment in config_version" do
+      value = "/some/script $environment"
+      expect = "/some/script production"
+      assert_does_interpolate_environment("config_version", value, expect)
+    end
+
+    it "does interpolate $environment in basemodulepath" do
+      value = "$confdir/environments/$environment/modules:$confdir/environments/$environment/other_modules"
+      expected = "#{confdir}/environments/production/modules:#{confdir}/environments/production/other_modules"
+      assert_does_interpolate_environment("basemodulepath", value, expected)
+    end
+
+    it "does interpolate $environment in default_manifest, which is fine, because this setting isn't used" do
+      value = "$confdir/manifests/$environment"
+      expected = "#{confdir}/manifests/production"
+
+      assert_does_interpolate_environment("default_manifest", value, expected)
+    end
+
+    it "raises something" do
+      value = expected = "whatareyouthinking$environment"
+      expect {
+        assert_does_interpolate_environment("environment", value, expected)
+      }.to raise_error(SystemStackError, /stack level too deep/)
+    end
+  end
+
+  def set_puppet_conf(confdir, settings)
+    write_file(File.join(confdir, "puppet.conf"), settings)
+  end
+
+  def set_environment_conf(environmentpath, environment, settings)
+    envdir = File.join(environmentpath, environment)
+    FileUtils.mkdir_p(envdir)
+    write_file(File.join(envdir, 'environment.conf'), settings)
+  end
+
+  def write_file(file, contents)
+    File.open(file, "w") do |f|
+      f.puts(contents)
+    end
+  end
+end
+end

data/spec/integration/provider/service/windows_spec.rb

@@ -0,0 +1,48 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+describe Puppet::Type.type(:service).provider(:windows), '(integration)',
+  :if => Puppet.features.microsoft_windows? do
+
+  require 'puppet/util/windows'
+
+  before :each do
+    Puppet::Type.type(:service).stubs(:defaultprovider).returns described_class
+  end
+
+  context 'should fail querying services that do not exist' do
+    let(:service) do
+      Puppet::Type.type(:service).new(:name => 'foobarservice1234')
+    end
+
+    it "with a Puppet::Error when querying enabled?" do
+      expect { service.provider.enabled? }.to raise_error(Puppet::Error)
+    end
+
+    it "with a Puppet::Error when querying status" do
+      expect { service.provider.status }.to raise_error(Puppet::Error)
+    end
+  end
+
+  context 'should return valid values when querying a service that does exist' do
+    let(:service) do
+      Puppet::Type.type(:service).new(:name => 'lmhosts')
+    end
+
+    it "with a valid boolean when asked if enabled" do
+      expect([:true, :false]).to include(service.provider.enabled?)
+    end
+
+    it "with a valid status when asked about status" do
+      expect([
+        :running,
+        :'continue pending',
+        :'pause pending',
+        :paused,
+        :running,
+        :'start pending',
+        :'stop pending',
+        :stopped]).to include(service.provider.status)
+    end
+  end
+end

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

@@ -447,7 +447,7 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
         describe "when the sid refers to a deleted trustee" do
           it "should retrieve the user sid" do
             sid = nil
-            user = Puppet::Util::Windows::ADSI::User.create("delete_me_user")
+            user = Puppet::Util::Windows::ADSI::User.create("puppet#{rand(10000)}")
             user.commit
             begin
               sid = Puppet::Util::Windows::ADSI::User.new(user.name).sid.to_s
@@ -463,7 +463,7 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
 
           it "should retrieve the group sid" do
             sid = nil
-            group = Puppet::Util::Windows::ADSI::Group.create("delete_me_group")
+            group = Puppet::Util::Windows::ADSI::Group.create("puppet#{rand(10000)}")
             group.commit
             begin
               sid = Puppet::Util::Windows::ADSI::Group.new(group.name).sid.to_s

data/spec/lib/puppet_spec/matchers.rb

@@ -21,6 +21,11 @@ RSpec::Matchers.define :have_matching_element do |expected|
   end
 end
 
+RSpec::Matchers.define :have_matching_log do |expected|
+  match do |actual|
+    actual.map(&:to_s).any? { |item| item =~ expected }
+  end
+end
 
 RSpec::Matchers.define :exit_with do |expected|
   actual = nil

data/spec/unit/functions/epp_spec.rb

@@ -1,4 +1,3 @@
-
 require 'spec_helper'
 
 describe "the epp function" do

data/spec/unit/network/http/compression_spec.rb

@@ -61,9 +61,9 @@ describe "http compression" do
       headers['accept-encoding'].should =~ /identity/
     end
 
-    it "should not add Accept-Encoding header if http compression is not available" do
+    it "should add an Accept-Encoding 'identity' header if http compression is disabled" do
       Puppet[:http_compression] = false
-      @uncompressor.add_accept_encoding({}).should == {}
+      @uncompressor.add_accept_encoding({}).should == {'accept-encoding' => 'identity'}
     end
 
     describe "when uncompressing response body" do

data/spec/unit/pops/loaders/dependency_loader_spec.rb

@@ -16,10 +16,10 @@ describe 'dependency loader' do
         'foo.rb' => 'Puppet::Functions.create_function("foo") { def foo; end; }'
       }}}}})
 
-      module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, loaders, 'testmodule', module_dir, 'test1')
-      dep_loader = Puppet::Pops::Loader::DependencyLoader.new(static_loader, 'test-dep', [module_loader])
+      loader = loader_for('testmodule', module_dir)
+
       expect do
-        dep_loader.load_typed(typed_name(:function, 'testmodule::foo')).value
+        loader.load_typed(typed_name(:function, 'testmodule::foo')).value
       end.to raise_error(ArgumentError, /produced mis-matched name, expected 'testmodule::foo', got foo/)
     end
 
@@ -28,10 +28,10 @@ describe 'dependency loader' do
       'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
         'foo.rb' => 'Puppet::Functions.create_function("testmodule::foo") { def foo; end; }'
       }}}}})
-      module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, loaders, 'testmodule', module_dir, 'test1')
-      dep_loader = Puppet::Pops::Loader::DependencyLoader.new(static_loader, 'test-dep', [module_loader])
 
-      function = dep_loader.load_typed(typed_name(:function, 'testmodule::foo')).value
+      loader = loader_for('testmodule', module_dir)
+
+      function = loader.load_typed(typed_name(:function, 'testmodule::foo')).value
 
       expect(function.class.name).to eq('testmodule::foo')
       expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
@@ -42,19 +42,24 @@ describe 'dependency loader' do
       'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
         'foo.rb' => 'Puppet::Functions.create_function("testmodule::foo") { def foo; end; }'
       }}}}})
-      module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, loaders, 'testmodule', module_dir, 'test1')
-      dep_loader = Puppet::Pops::Loader::DependencyLoader.new(static_loader, 'test-dep', [module_loader])
 
-      function = dep_loader.load_typed(typed_name(:function, 'testmodule::foo')).value
+      loader = loader_for('testmodule', module_dir)
+
+      function = loader.load_typed(typed_name(:function, 'testmodule::foo')).value
       expect(function.class.name).to eq('testmodule::foo')
       expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
 
-      function = dep_loader.load_typed(typed_name(:function, 'testmodule::foo')).value
+      function = loader.load_typed(typed_name(:function, 'testmodule::foo')).value
       expect(function.class.name).to eq('testmodule::foo')
       expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
     end
   end
 
+  def loader_for(name, dir)
+      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, name, dir)
+      Puppet::Pops::Loader::DependencyLoader.new(static_loader, 'test-dep', [module_loader])
+  end
+
   def typed_name(type, name)
     Puppet::Pops::Loader::Loader::TypedName.new(type, name)
   end

data/spec/unit/pops/loaders/loader_paths_spec.rb

@@ -9,47 +9,35 @@ describe 'loader paths' do
   let(:static_loader) { Puppet::Pops::Loader::StaticLoader.new() }
   let(:unused_loaders) { nil }
 
-  describe 'the relative_path_for_types method' do
-    it 'produces paths to load in precendence order' do
-      module_dir = dir_containing('testmodule', {
-        'functions' => {},
-        'lib' => {
-          'puppet' => {
-            'functions' => {},
-          }}})
-      module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, unused_loaders, 'testmodule', module_dir, 'test1')
-
-      effective_paths = Puppet::Pops::Loader::LoaderPaths.relative_paths_for_type(:function, module_loader)
-
-      expect(effective_paths.collect(&:generic_path)).to eq([
-        File.join(module_dir, 'lib', 'puppet', 'functions')
-      ])
-    end
-
-    it 'module loader has smart-paths that prunes unavailable paths' do
-      module_dir = dir_containing('testmodule', {'lib' => {'puppet' => {'functions' => {'foo.rb' => 'Puppet::Functions.create_function("testmodule::foo") { def foo; end; }' }}}})
-      module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, unused_loaders, 'testmodule', module_dir, 'test1')
-
-      effective_paths = module_loader.smart_paths.effective_paths(:function)
-
-      expect(effective_paths.size).to be_eql(1)
-      expect(effective_paths[0].generic_path).to be_eql(File.join(module_dir, 'lib', 'puppet', 'functions'))
-    end
-
-    it 'all function smart-paths produces entries if they exist' do
-      module_dir = dir_containing('testmodule', {
-        'lib' => {
-          'puppet' => {
-            'functions' => {'foo4x.rb' => 'ignored in this test'},
-          }}})
-      module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, unused_loaders, 'testmodule', module_dir, 'test1')
-
-      effective_paths = module_loader.smart_paths.effective_paths(:function)
-
-      expect(effective_paths.size).to eq(1)
-      expect(module_loader.path_index.size).to eq(1)
-      path_index = module_loader.path_index
-      expect(path_index).to include(File.join(module_dir, 'lib', 'puppet', 'functions', 'foo4x.rb'))
-    end
+  it 'module loader has smart-paths that prunes unavailable paths' do
+    module_dir = dir_containing('testmodule', {'lib' => {'puppet' => {'functions' =>
+      {'foo.rb' =>
+        'Puppet::Functions.create_function("testmodule::foo") {
+          def foo; end;
+        }'
+      }
+    }}})
+    module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, unused_loaders, 'testmodule', module_dir)
+
+    effective_paths = module_loader.smart_paths.effective_paths(:function)
+
+    expect(effective_paths.size).to be_eql(1)
+    expect(effective_paths[0].generic_path).to be_eql(File.join(module_dir, 'lib', 'puppet', 'functions'))
+  end
+
+  it 'all function smart-paths produces entries if they exist' do
+    module_dir = dir_containing('testmodule', {
+      'lib' => {
+        'puppet' => {
+          'functions' => {'foo4x.rb' => 'ignored in this test'},
+        }}})
+    module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, unused_loaders, 'testmodule', module_dir)
+
+    effective_paths = module_loader.smart_paths.effective_paths(:function)
+
+    expect(effective_paths.size).to eq(1)
+    expect(module_loader.path_index.size).to eq(1)
+    path_index = module_loader.path_index
+    expect(path_index).to include(File.join(module_dir, 'lib', 'puppet', 'functions', 'foo4x.rb'))
   end
 end

data/spec/unit/pops/loaders/module_loaders_spec.rb

@@ -26,7 +26,7 @@ describe 'FileBased module loader' do
           }
         })
 
-    module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, loaders, 'testmodule', module_dir, 'test1')
+    module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
     function = module_loader.load_typed(typed_name(:function, 'foo4x')).value
 
     expect(function.class.name).to eq('foo4x')
@@ -51,7 +51,7 @@ describe 'FileBased module loader' do
           }
       }})
 
-    module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, loaders, 'testmodule', module_dir, 'test1')
+    module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
     function = module_loader.load_typed(typed_name(:function, 'testmodule::foo4x')).value
     expect(function.class.name).to eq('testmodule::foo4x')
     expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
@@ -68,7 +68,7 @@ describe 'FileBased module loader' do
            end
         CODE
       }}}}})
-    module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, loaders, 'testmodule', module_dir, 'test1')
+    module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
 
     module_dir2 = dir_containing('testmodule2', {
       'lib' => { 'puppet' => { 'functions' => { 'testmodule2' => {

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

@@ -51,6 +51,14 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
       }.to raise_error(Puppet::Error, /Cannot start #{name}, error was: The service name is invalid./)
     end
 
+    it "raises an error if the service doesn't exist" do
+      Win32::Service.expects(:config_info).with(name).raises(SystemCallError, 'OpenService')
+
+      expect {
+        provider.start
+      }.to raise_error(Puppet::Error, /Cannot get start type for #{name}/)
+    end
+
     describe "when the service is disabled" do
       before :each do
         config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_DISABLED)
@@ -112,6 +120,14 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
         provider.status.should == :running
       end
     end
+
+    it "raises an error if the service doesn't exist" do
+      Win32::Service.expects(:status).with(name).raises(SystemCallError, 'OpenService')
+
+      expect {
+        provider.status
+      }.to raise_error(Puppet::Error, /Cannot get status of #{name}/)
+    end
   end
 
   describe "#restart" do
@@ -146,6 +162,14 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
       provider.enabled?.should == :false
     end
 
+    it "raises an error if the service doesn't exist" do
+      Win32::Service.expects(:config_info).with(name).raises(SystemCallError, 'OpenService')
+
+      expect {
+        provider.enabled?
+      }.to raise_error(Puppet::Error, /Cannot get start type for #{name}/)
+    end
+
     # We need to guard this section explicitly since rspec will always
     # construct all examples, even if it isn't going to run them.
     if Puppet.features.microsoft_windows?
@@ -165,6 +189,14 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
       Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_AUTO_START).returns(Win32::Service)
       provider.enable
     end
+
+    it "raises an error if the service doesn't exist" do
+      Win32::Service.expects(:configure).with(has_entry('service_name' => name)).raises(SystemCallError, 'OpenService')
+
+      expect {
+        provider.enable
+      }.to raise_error(Puppet::Error, /Cannot enable #{name}/)
+    end
   end
 
   describe "#disable" do
@@ -172,6 +204,14 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
       Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_DISABLED).returns(Win32::Service)
       provider.disable
      end
+
+    it "raises an error if the service doesn't exist" do
+      Win32::Service.expects(:configure).with(has_entry('service_name' => name)).raises(SystemCallError, 'OpenService')
+
+      expect {
+        provider.disable
+      }.to raise_error(Puppet::Error, /Cannot disable #{name}/)
+    end
   end
 
   describe "#manual_start" do
@@ -179,5 +219,13 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
       Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_DEMAND_START).returns(Win32::Service)
       provider.manual_start
     end
+
+    it "raises an error if the service doesn't exist" do
+      Win32::Service.expects(:configure).with(has_entry('service_name' => name)).raises(SystemCallError, 'OpenService')
+
+      expect {
+        provider.manual_start
+      }.to raise_error(Puppet::Error, /Cannot enable #{name}/)
+    end
   end
 end

data/spec/unit/resource_spec.rb

@@ -85,6 +85,12 @@ describe Puppet::Resource do
     ref.title.should =="baz"
   end
 
+  it "should not interpret the title as a reference if the type is a non component or whit reference" do
+    ref = Puppet::Resource.new("Notify", "foo::bar[baz]")
+    ref.type.should == "Notify"
+    ref.title.should =="foo::bar[baz]"
+  end
+
   it "should be able to extract its information from a Puppet::Type instance" do
     ral = Puppet::Type.type(:file).new :path => basepath+"/foo"
     ref = Puppet::Resource.new(ral)

data/spec/unit/settings_spec.rb

@@ -2,9 +2,12 @@
 require 'spec_helper'
 require 'ostruct'
 require 'puppet/settings/errors'
+require 'puppet_spec/files'
+require 'matchers/resource'
 
 describe Puppet::Settings do
   include PuppetSpec::Files
+  include Matchers::Resource
 
   let(:main_config_file_default_location) do
     File.join(Puppet::Util::RunMode[:master].conf_dir, "puppet.conf")
@@ -1338,6 +1341,16 @@ describe Puppet::Settings do
       @settings.to_catalog
     end
 
+    it "should ignore manifestdir if environmentpath is set" do
+      @settings.define_settings :main,
+        :manifestdir => { :type => :directory, :default => @prefix+"/manifestdir", :desc => "a" },
+        :environmentpath => { :type => :path, :default => @prefix+"/envs", :desc => "a" }
+
+      catalog = @settings.to_catalog(:main)
+
+      expect(catalog).to_not have_resource("File[#{@prefix}/manifestdir]")
+    end
+
     describe "on Microsoft Windows" do
       before :each do
         Puppet.features.stubs(:root?).returns true
@@ -1395,6 +1408,13 @@ describe Puppet::Settings do
         catalog = @settings.to_catalog
         expect(catalog.resource_keys).to include(["File", "#{default_path}/production"])
       end
+
+      it "does not add if the path to the default directory environment exists as a symlink", :if => Puppet.features.manages_symlinks? do
+        Dir.mkdir(default_path)
+        Puppet::FileSystem.symlink("#{tmpenv}/nowhere", File.join(default_path, 'production'))
+        catalog = @settings.to_catalog
+        expect(catalog.resource_keys).to_not include(["File", "#{default_path}/production"])
+      end
     end
 
     describe "when adding users and groups to the catalog" do

data/spec/unit/ssl/validator_spec.rb

@@ -39,14 +39,80 @@ describe Puppet::SSL::Validator::DefaultValidator do
 
     context 'When pre-verification is not OK' do
       context 'and the ssl_context is in an error state' do
-        before :each do
-          ssl_context.stubs(:error_string).returns("Something went wrong.")
+        let(:root_subject) { OpenSSL::X509::Certificate.new(root_ca).subject.to_s }
+        let(:code) { OpenSSL::X509::V_ERR_INVALID_CA }
+
+        it 'rejects the connection' do
+          ssl_context.stubs(:error_string).returns("Something went wrong")
+          ssl_context.stubs(:error).returns(code)
+
+          expect(subject.call(false, ssl_context)).to eq(false)
         end
 
         it 'makes the error available via #verify_errors' do
+          ssl_context.stubs(:error_string).returns("Something went wrong")
+          ssl_context.stubs(:error).returns(code)
+
+          subject.call(false, ssl_context)
+          expect(subject.verify_errors).to eq(["Something went wrong for #{root_subject}"])
+        end
+
+        it 'uses a generic message if error_string is nil' do
+          ssl_context.stubs(:error_string).returns(nil)
+          ssl_context.stubs(:error).returns(code)
+
           subject.call(false, ssl_context)
-          msg_suffix = OpenSSL::X509::Certificate.new(root_ca).subject
-          subject.verify_errors.should == ["Something went wrong. for #{msg_suffix}"]
+          expect(subject.verify_errors).to eq(["OpenSSL error #{code} for #{root_subject}"])
+        end
+
+        it 'uses 0 for nil error codes' do
+          ssl_context.stubs(:error_string).returns("Something went wrong")
+          ssl_context.stubs(:error).returns(nil)
+
+          subject.call(false, ssl_context)
+          expect(subject.verify_errors).to eq(["Something went wrong for #{root_subject}"])
+        end
+
+        context "when CRL is not yet valid" do
+          before :each do
+            ssl_context.stubs(:error_string).returns("CRL is not yet valid")
+            ssl_context.stubs(:error).returns(OpenSSL::X509::V_ERR_CRL_NOT_YET_VALID)
+          end
+
+          it 'rejects nil CRL' do
+            ssl_context.stubs(:current_crl).returns(nil)
+
+            expect(subject.call(false, ssl_context)).to eq(false)
+            expect(subject.verify_errors).to eq(["CRL is not yet valid"])
+          end
+
+          it 'includes the CRL issuer in the verify error message' do
+            crl = OpenSSL::X509::CRL.new
+            crl.issuer = OpenSSL::X509::Name.new([['CN','Puppet CA: puppetmaster.example.com']])
+            crl.last_update = Time.now + 24 * 60 * 60
+            ssl_context.stubs(:current_crl).returns(crl)
+
+            subject.call(false, ssl_context)
+            expect(subject.verify_errors).to eq(["CRL is not yet valid for /CN=Puppet CA: puppetmaster.example.com"])
+          end
+
+          it 'rejects CRLs whose last_update time is more than 5 minutes in the future' do
+            crl = OpenSSL::X509::CRL.new
+            crl.issuer = OpenSSL::X509::Name.new([['CN','Puppet CA: puppetmaster.example.com']])
+            crl.last_update = Time.now + 24 * 60 * 60
+            ssl_context.stubs(:current_crl).returns(crl)
+
+            expect(subject.call(false, ssl_context)).to eq(false)
+          end
+
+          it 'accepts CRLs whose last_update time is 10 seconds in the future' do
+            crl = OpenSSL::X509::CRL.new
+            crl.issuer = OpenSSL::X509::Name.new([['CN','Puppet CA: puppetmaster.example.com']])
+            crl.last_update = Time.now + 10
+            ssl_context.stubs(:current_crl).returns(crl)
+
+            expect(subject.call(false, ssl_context)).to eq(true)
+          end
         end
       end
     end
@@ -54,7 +120,7 @@ describe Puppet::SSL::Validator::DefaultValidator do
     context 'When pre-verification is OK' do
       context 'and the ssl_context is in an error state' do
         before :each do
-          ssl_context.stubs(:error_string).returns("Something went wrong.")
+          ssl_context.stubs(:error_string).returns("Something went wrong")
         end
 
         it 'does not make the error available via #verify_errors' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet
 version: !ruby/object:Gem::Version
-  version: 3.7.0
+  version: 3.7.1
 platform: x64-mingw32
 authors:
 - Puppet Labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-03 00:00:00.000000000 Z
+date: 2014-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: facter
@@ -1829,6 +1829,7 @@ files:
 - spec/integration/defaults_spec.rb
 - spec/integration/directory_environments_spec.rb
 - spec/integration/environments/default_manifest_spec.rb
+- spec/integration/environments/settings_interpolation_spec.rb
 - spec/integration/faces/ca_spec.rb
 - spec/integration/faces/documentation_spec.rb
 - spec/integration/faces/plugin_spec.rb
@@ -1868,6 +1869,7 @@ files:
 - spec/integration/provider/package_spec.rb
 - spec/integration/provider/service/init_spec.rb
 - spec/integration/provider/service/systemd_spec.rb
+- spec/integration/provider/service/windows_spec.rb
 - spec/integration/provider/ssh_authorized_key_spec.rb
 - spec/integration/reference/providers_spec.rb
 - spec/integration/reports_spec.rb
@@ -2906,6 +2908,7 @@ test_files:
 - spec/integration/defaults_spec.rb
 - spec/integration/directory_environments_spec.rb
 - spec/integration/environments/default_manifest_spec.rb
+- spec/integration/environments/settings_interpolation_spec.rb
 - spec/integration/faces/ca_spec.rb
 - spec/integration/faces/documentation_spec.rb
 - spec/integration/faces/plugin_spec.rb
@@ -2945,6 +2948,7 @@ test_files:
 - spec/integration/provider/package_spec.rb
 - spec/integration/provider/service/init_spec.rb
 - spec/integration/provider/service/systemd_spec.rb
+- spec/integration/provider/service/windows_spec.rb
 - spec/integration/provider/ssh_authorized_key_spec.rb
 - spec/integration/reference/providers_spec.rb
 - spec/integration/reports_spec.rb