puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/integration/configurer_spec.rb

@@ -49,19 +49,19 @@ describe Puppet::Configurer do
       # sticky bit only applies to directories in windows
       file_mode = Puppet.features.microsoft_windows? ? '666' : '100666'
 
-      Puppet::FileSystem.stat(Puppet[:lastrunfile]).mode.to_s(8).should == file_mode
+      expect(Puppet::FileSystem.stat(Puppet[:lastrunfile]).mode.to_s(8)).to eq(file_mode)
 
       summary = nil
       File.open(Puppet[:lastrunfile], "r") do |fd|
         summary = YAML.load(fd.read)
       end
 
-      summary.should be_a(Hash)
+      expect(summary).to be_a(Hash)
       %w{time changes events resources}.each do |key|
-        summary.should be_key(key)
+        expect(summary).to be_key(key)
       end
-      summary["time"].should be_key("notify")
-      summary["time"]["last_run"].should be_between(t1, t2)
+      expect(summary["time"]).to be_key("notify")
+      expect(summary["time"]["last_run"]).to be_between(t1, t2)
     end
   end
 end

data/spec/integration/data_binding.rb

@@ -17,13 +17,16 @@ describe "Data binding" do
     configure_hiera_for({
       "testing::binding::value" => "the value",
       "testing::binding::calling_class" => "%{calling_class}",
+      "testing::binding::calling_class_path" => "%{calling_class_path}",
       "testing::binding::calling_module" => "%{calling_module}"
+     
     })
 
     create_manifest_in_module("testing", "binding.pp",
                               <<-MANIFEST)
     class testing::binding($value,
                            $calling_class,
+                           $calling_class_path,
                            $calling_module) {}
     MANIFEST
 
@@ -32,6 +35,7 @@ describe "Data binding" do
 
     expect(resource[:value]).to eq("the value")
     expect(resource[:calling_class]).to eq("testing::binding")
+    expect(resource[:calling_class_path]).to eq("testing/binding")
     expect(resource[:calling_module]).to eq("testing")
   end
 

data/spec/integration/defaults_spec.rb

@@ -2,7 +2,6 @@
 require 'spec_helper'
 
 require 'puppet/defaults'
-require 'puppet/rails'
 
 describe "Puppet defaults" do
 
@@ -42,256 +41,156 @@ describe "Puppet defaults" do
   describe "when setting :node_name_value" do
     it "should default to the value of :certname" do
       Puppet.settings[:certname] = 'blargle'
-      Puppet.settings[:node_name_value].should == 'blargle'
+      expect(Puppet.settings[:node_name_value]).to eq('blargle')
     end
   end
 
   describe "when setting the :node_name_fact" do
     it "should fail when also setting :node_name_value" do
-      lambda do
+      expect do
         Puppet.settings[:node_name_value] = "some value"
         Puppet.settings[:node_name_fact] = "some_fact"
-      end.should raise_error("Cannot specify both the node_name_value and node_name_fact settings")
+      end.to raise_error("Cannot specify both the node_name_value and node_name_fact settings")
     end
 
     it "should not fail when using the default for :node_name_value" do
-      lambda do
+      expect do
         Puppet.settings[:node_name_fact] = "some_fact"
-      end.should_not raise_error
-    end
-  end
-
-  describe "when :certdnsnames is set" do
-    it "should not fail" do
-      expect { Puppet[:certdnsnames] = 'fred:wilma' }.to_not raise_error
-    end
-
-    it "should warn the value is ignored" do
-      Puppet.expects(:warning).with {|msg| msg =~ /CVE-2011-3872/ }
-      Puppet[:certdnsnames] = 'fred:wilma'
-    end
-  end
-
-  describe "when setting the :catalog_format" do
-    it "should log a deprecation notice" do
-      Puppet.expects(:deprecation_warning)
-      Puppet.settings[:catalog_format] = 'marshal'
-    end
-    it "should copy the value to :preferred_serialization_format" do
-      Puppet.settings[:catalog_format] = 'marshal'
-      Puppet.settings[:preferred_serialization_format].should == 'marshal'
+      end.not_to raise_error
     end
   end
 
   it "should have a clientyamldir setting" do
-    Puppet.settings[:clientyamldir].should_not be_nil
+    expect(Puppet.settings[:clientyamldir]).not_to be_nil
   end
 
   it "should have different values for the yamldir and clientyamldir" do
-    Puppet.settings[:yamldir].should_not == Puppet.settings[:clientyamldir]
+    expect(Puppet.settings[:yamldir]).not_to eq(Puppet.settings[:clientyamldir])
   end
 
   it "should have a client_datadir setting" do
-    Puppet.settings[:client_datadir].should_not be_nil
+    expect(Puppet.settings[:client_datadir]).not_to be_nil
   end
 
   it "should have different values for the server_datadir and client_datadir" do
-    Puppet.settings[:server_datadir].should_not == Puppet.settings[:client_datadir]
+    expect(Puppet.settings[:server_datadir]).not_to eq(Puppet.settings[:client_datadir])
   end
 
   # See #1232
   it "should not specify a user or group for the clientyamldir" do
-    Puppet.settings.setting(:clientyamldir).owner.should be_nil
-    Puppet.settings.setting(:clientyamldir).group.should be_nil
+    expect(Puppet.settings.setting(:clientyamldir).owner).to be_nil
+    expect(Puppet.settings.setting(:clientyamldir).group).to be_nil
   end
 
   it "should use the service user and group for the yamldir" do
     Puppet.settings.stubs(:service_user_available?).returns true
     Puppet.settings.stubs(:service_group_available?).returns true
-    Puppet.settings.setting(:yamldir).owner.should == Puppet.settings[:user]
-    Puppet.settings.setting(:yamldir).group.should == Puppet.settings[:group]
+    expect(Puppet.settings.setting(:yamldir).owner).to eq(Puppet.settings[:user])
+    expect(Puppet.settings.setting(:yamldir).group).to eq(Puppet.settings[:group])
   end
 
   it "should specify that the host private key should be owned by the service user" do
     Puppet.settings.stubs(:service_user_available?).returns true
-    Puppet.settings.setting(:hostprivkey).owner.should == Puppet.settings[:user]
+    expect(Puppet.settings.setting(:hostprivkey).owner).to eq(Puppet.settings[:user])
   end
 
   it "should specify that the host certificate should be owned by the service user" do
     Puppet.settings.stubs(:service_user_available?).returns true
-    Puppet.settings.setting(:hostcert).owner.should == Puppet.settings[:user]
+    expect(Puppet.settings.setting(:hostcert).owner).to eq(Puppet.settings[:user])
   end
 
   [:modulepath, :factpath].each do |setting|
     it "should configure '#{setting}' not to be a file setting, so multi-directory settings are acceptable" do
-      Puppet.settings.setting(setting).should be_instance_of(Puppet::Settings::PathSetting)
+      expect(Puppet.settings.setting(setting)).to be_instance_of(Puppet::Settings::PathSetting)
     end
   end
 
-  describe "on a Unix-like platform it", :as_platform => :posix do
+  describe "on a Unix-like platform it", :if => Puppet.features.posix? do
     it "should add /usr/sbin and /sbin to the path if they're not there" do
       Puppet::Util.withenv("PATH" => "/usr/bin#{File::PATH_SEPARATOR}/usr/local/bin") do
         Puppet.settings[:path] = "none" # this causes it to ignore the setting
-        ENV["PATH"].split(File::PATH_SEPARATOR).should be_include("/usr/sbin")
-        ENV["PATH"].split(File::PATH_SEPARATOR).should be_include("/sbin")
+        expect(ENV["PATH"].split(File::PATH_SEPARATOR)).to be_include("/usr/sbin")
+        expect(ENV["PATH"].split(File::PATH_SEPARATOR)).to be_include("/sbin")
       end
     end
   end
 
-  describe "on a Windows-like platform it", :as_platform => :windows do
+  describe "on a Windows-like platform it", :if => Puppet.features.microsoft_windows? do
     it "should not add anything" do
       path = "c:\\windows\\system32#{File::PATH_SEPARATOR}c:\\windows"
       Puppet::Util.withenv("PATH" => path) do
         Puppet.settings[:path] = "none" # this causes it to ignore the setting
-        ENV["PATH"].should == path
+        expect(ENV["PATH"]).to eq(path)
       end
     end
   end
 
   it "should default to pson for the preferred serialization format" do
-    Puppet.settings.value(:preferred_serialization_format).should == "pson"
-  end
-
-  describe "when enabling storeconfigs" do
-    before do
-      Puppet::Resource::Catalog.indirection.stubs(:cache_class=)
-      Puppet::Node::Facts.indirection.stubs(:cache_class=)
-      Puppet::Node.indirection.stubs(:cache_class=)
-
-      Puppet.features.stubs(:rails?).returns true
-    end
-
-    it "should set the Catalog cache class to :store_configs" do
-      Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(:store_configs)
-      Puppet.settings[:storeconfigs] = true
-    end
-
-    it "should not set the Catalog cache class to :store_configs if asynchronous storeconfigs is enabled" do
-      Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(:store_configs).never
-      Puppet.settings[:async_storeconfigs] = true
-      Puppet.settings[:storeconfigs] = true
-    end
-
-    it "should set the Facts cache class to :store_configs" do
-      Puppet::Node::Facts.indirection.expects(:cache_class=).with(:store_configs)
-      Puppet.settings[:storeconfigs] = true
-    end
-
-    it "does not change the Node cache" do
-      Puppet::Node.indirection.expects(:cache_class=).never
-      Puppet.settings[:storeconfigs] = true
-    end
-  end
-
-  describe "when enabling asynchronous storeconfigs" do
-    before do
-      Puppet::Resource::Catalog.indirection.stubs(:cache_class=)
-      Puppet::Node::Facts.indirection.stubs(:cache_class=)
-      Puppet::Node.indirection.stubs(:cache_class=)
-      Puppet.features.stubs(:rails?).returns true
-    end
-
-    it "should set storeconfigs to true" do
-      Puppet.settings[:async_storeconfigs] = true
-      Puppet.settings[:storeconfigs].should be_true
-    end
-
-    it "should set the Catalog cache class to :queue" do
-      Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(:queue)
-      Puppet.settings[:async_storeconfigs] = true
-    end
-
-    it "should set the Facts cache class to :store_configs" do
-      Puppet::Node::Facts.indirection.expects(:cache_class=).with(:store_configs)
-      Puppet.settings[:storeconfigs] = true
-    end
-
-    it "does not change the Node cache" do
-      Puppet::Node.indirection.expects(:cache_class=).never
-      Puppet.settings[:storeconfigs] = true
-    end
-  end
-
-  describe "when enabling thin storeconfigs" do
-    before do
-      Puppet::Resource::Catalog.indirection.stubs(:cache_class=)
-      Puppet::Node::Facts.indirection.stubs(:cache_class=)
-      Puppet::Node.indirection.stubs(:cache_class=)
-      Puppet.features.stubs(:rails?).returns true
-    end
-
-    it "should set storeconfigs to true" do
-      Puppet.settings[:thin_storeconfigs] = true
-      Puppet.settings[:storeconfigs].should be_true
-    end
+    expect(Puppet.settings.value(:preferred_serialization_format)).to eq("pson")
   end
 
   it "should have a setting for determining the configuration version and should default to an empty string" do
-    Puppet.settings[:config_version].should == ""
+    expect(Puppet.settings[:config_version]).to eq("")
   end
 
   describe "when enabling reports" do
     it "should use the default server value when report server is unspecified" do
       Puppet.settings[:server] = "server"
-      Puppet.settings[:report_server].should == "server"
+      expect(Puppet.settings[:report_server]).to eq("server")
     end
 
     it "should use the default masterport value when report port is unspecified" do
       Puppet.settings[:masterport] = "1234"
-      Puppet.settings[:report_port].should == "1234"
+      expect(Puppet.settings[:report_port]).to eq("1234")
     end
 
     it "should use report_port when set" do
       Puppet.settings[:masterport] = "1234"
       Puppet.settings[:report_port] = "5678"
-      Puppet.settings[:report_port].should == "5678"
+      expect(Puppet.settings[:report_port]).to eq("5678")
     end
   end
 
   it "should have a :caname setting that defaults to the cert name" do
     Puppet.settings[:certname] = "foo"
-    Puppet.settings[:ca_name].should == "Puppet CA: foo"
+    expect(Puppet.settings[:ca_name]).to eq("Puppet CA: foo")
   end
 
   it "should have a 'prerun_command' that defaults to the empty string" do
-    Puppet.settings[:prerun_command].should == ""
+    expect(Puppet.settings[:prerun_command]).to eq("")
   end
 
   it "should have a 'postrun_command' that defaults to the empty string" do
-    Puppet.settings[:postrun_command].should == ""
+    expect(Puppet.settings[:postrun_command]).to eq("")
   end
 
   it "should have a 'certificate_revocation' setting that defaults to true" do
-    Puppet.settings[:certificate_revocation].should be_true
-  end
-
-  it "should have an http_compression setting that defaults to false" do
-    Puppet.settings[:http_compression].should be_false
+    expect(Puppet.settings[:certificate_revocation]).to be_truthy
   end
 
   describe "reportdir" do
     subject { Puppet.settings[:reportdir] }
-    it { should == "#{Puppet[:vardir]}/reports" }
+    it { is_expected.to eq("#{Puppet[:vardir]}/reports") }
   end
 
   describe "reporturl" do
     subject { Puppet.settings[:reporturl] }
-    it { should == "http://localhost:3000/reports/upload" }
+    it { is_expected.to eq("http://localhost:3000/reports/upload") }
   end
 
   describe "when configuring color" do
     subject { Puppet.settings[:color] }
-    it { should == "ansi" }
+    it { is_expected.to eq("ansi") }
   end
 
   describe "daemonize" do
     it "should default to true", :unless => Puppet.features.microsoft_windows? do
-      Puppet.settings[:daemonize].should == true
+      expect(Puppet.settings[:daemonize]).to eq(true)
     end
 
     describe "on Windows", :if => Puppet.features.microsoft_windows? do
       it "should default to false" do
-        Puppet.settings[:daemonize].should == false
+        expect(Puppet.settings[:daemonize]).to eq(false)
       end
 
       it "should raise an error if set to true" do
@@ -302,34 +201,34 @@ describe "Puppet defaults" do
 
   describe "diff" do
     it "should default to 'diff' on POSIX", :unless => Puppet.features.microsoft_windows? do
-      Puppet.settings[:diff].should == 'diff'
+      expect(Puppet.settings[:diff]).to eq('diff')
     end
 
     it "should default to '' on Windows", :if => Puppet.features.microsoft_windows? do
-      Puppet.settings[:diff].should == ''
+      expect(Puppet.settings[:diff]).to eq('')
     end
   end
 
   describe "when configuring hiera" do
     it "should have a hiera_config setting" do
-      Puppet.settings[:hiera_config].should_not be_nil
+      expect(Puppet.settings[:hiera_config]).not_to be_nil
     end
   end
 
   describe "when configuring the data_binding terminus" do
     it "should have a data_binding_terminus setting" do
-      Puppet.settings[:data_binding_terminus].should_not be_nil
+      expect(Puppet.settings[:data_binding_terminus]).not_to be_nil
     end
 
     it "should be set to hiera by default" do
-      Puppet.settings[:data_binding_terminus].should == :hiera
+      expect(Puppet.settings[:data_binding_terminus]).to eq(:hiera)
     end
   end
 
   describe "agent_catalog_run_lockfile" do
     it "(#2888) is not a file setting so it is absent from the Settings catalog" do
-      Puppet.settings.setting(:agent_catalog_run_lockfile).should_not be_a_kind_of Puppet::Settings::FileSetting
-      Puppet.settings.setting(:agent_catalog_run_lockfile).should be_a Puppet::Settings::StringSetting
+      expect(Puppet.settings.setting(:agent_catalog_run_lockfile)).not_to be_a_kind_of Puppet::Settings::FileSetting
+      expect(Puppet.settings.setting(:agent_catalog_run_lockfile)).to be_a Puppet::Settings::StringSetting
     end
   end
 end

data/spec/integration/directory_environments_spec.rb

@@ -19,15 +19,15 @@ describe "directory environments" do
       Puppet.settings.initialize_global_settings(args)
       expect do
         expect { puppet.run }.to exit_with(0)
-      end.to have_printed('direnv/modules')
+      end.to have_printed('/direnv/modules')
     end
 
     it "config prints the cli --modulepath despite environment" do
-      args << '--modulepath' << 'completely/different'
+      args << '--modulepath' << '/completely/different'
       Puppet.settings.initialize_global_settings(args)
       expect do
         expect { puppet.run }.to exit_with(0)
-      end.to have_printed('completely/different')
+      end.to have_printed('/completely/different')
     end
   end
 

data/spec/integration/environments/default_manifest_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module EnvironmentsDefaultManifestsSpec
 describe "default manifests" do
 
-  shared_examples_for "puppet with default_manifest settings" do
+  context "puppet with default_manifest settings" do
     let(:confdir) { Puppet[:confdir] }
     let(:environmentpath) { File.expand_path("envdir", confdir) }
 
@@ -188,54 +188,6 @@ describe "default manifests" do
         expect { Puppet.initialize_settings }.to raise_error(Puppet::Settings::ValidationError, /default_manifest.*must be.*absolute.*when.*disable_per_environment_manifest.*true/)
       end
     end
-
-    context "in legacy environments" do
-      let(:environmentpath) { '' }
-      let(:manifestsdir) { File.expand_path("default_manifests", confdir) }
-      let(:legacy_manifestsdir) { File.expand_path('manifests', confdir) }
-
-      before(:each) do
-        FileUtils.mkdir_p(manifestsdir)
-
-        File.open(File.join(confdir, "puppet.conf"), "w") do |f|
-          f.puts(<<-EOF)
-  default_manifest=#{manifestsdir}
-  disable_per_environment_manifest=true
-  manifest=#{legacy_manifestsdir}
-          EOF
-        end
-
-        File.open(File.join(manifestsdir, "site.pp"), "w") do |f|
-          f.puts("notify { 'ManifestFromAbsoluteDefaultManifest': }")
-        end
-      end
-
-      it "has no effect on compilation" do
-        FileUtils.mkdir_p(legacy_manifestsdir)
-
-        File.open(File.join(legacy_manifestsdir, "site.pp"), "w") do |f|
-          f.puts("notify { 'ManifestFromLegacy': }")
-        end
-
-        expect(a_catalog_compiled_for_environment('testing')).to(
-          include_resource('Notify[ManifestFromLegacy]')
-        )
-      end
-    end
-  end
-
-  describe 'using future parser' do
-    before :each do
-      Puppet[:parser] = 'future'
-    end
-    it_behaves_like 'puppet with default_manifest settings'
-  end
-
-  describe 'using current parser' do
-    before :each do
-      Puppet[:parser] = 'current'
-    end
-    it_behaves_like 'puppet with default_manifest settings'
   end
 
   RSpec::Matchers.define :include_resource do |expected|
@@ -243,11 +195,11 @@ describe "default manifests" do
       actual.resources.map(&:ref).include?(expected)
     end
 
-    def failure_message_for_should
+    def failure_message
       "expected #{@actual.resources.map(&:ref)} to include #{expected}"
     end
 
-    def failure_message_for_should_not
+    def failure_message_when_negated
       "expected #{@actual.resources.map(&:ref)} not to include #{expected}"
     end
   end