puppet 5.5.12-x64-mingw32 → 5.5.13-x64-mingw32

data/spec/unit/scheduler/job_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/scheduler'
 

data/spec/unit/scheduler/scheduler_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/scheduler'
 

data/spec/unit/scheduler/splay_job_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/scheduler'
 
@@ -29,7 +28,7 @@ describe Puppet::Scheduler::SplayJob do
 
   it "is not immediately ready if splayed" do
     job.start_time = start_time
-    job.expects(:splay).returns(6)
+    expect(job).to receive(:splay).and_return(6)
     expect(job.ready?(start_time)).not_to be
   end
 end

data/spec/unit/settings/array_setting_spec.rb

@@ -4,7 +4,7 @@ require 'puppet/settings'
 require 'puppet/settings/array_setting'
 
 describe Puppet::Settings::ArraySetting do
-  subject { described_class.new(:settings => stub('settings'), :desc => "test") }
+  subject { described_class.new(:settings => double('settings'), :desc => "test") }
 
   it "is of type :array" do
     expect(subject.type).to eq :array

data/spec/unit/settings/autosign_setting_spec.rb

@@ -6,11 +6,11 @@ require 'puppet/type/file'
 
 describe Puppet::Settings::AutosignSetting do
   let(:settings) do
-    s = stub('settings')
-    s.stubs(:[]).with(:mkusers).returns true
-    s.stubs(:[]).with(:user).returns 'puppet'
-    s.stubs(:[]).with(:group).returns 'puppet'
-    s.stubs(:[]).with(:manage_internal_file_permissions).returns true
+    s = double('settings')
+    allow(s).to receive(:[]).with(:mkusers).and_return(true)
+    allow(s).to receive(:[]).with(:user).and_return('puppet')
+    allow(s).to receive(:[]).with(:group).and_return('puppet')
+    allow(s).to receive(:[]).with(:manage_internal_file_permissions).and_return(true)
     s
   end
 
@@ -74,9 +74,9 @@ describe Puppet::Settings::AutosignSetting do
   describe "converting the setting to a 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.features.expects(:root?).returns(true)
+      allow(settings).to receive(:value).with('autosign', nil, false).and_return(path)
+      allow(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+      expect(Puppet.features).to receive(:root?).and_return(true)
 
       setting.mode = '0664'
       setting.owner = 'service'
@@ -92,7 +92,7 @@ describe Puppet::Settings::AutosignSetting do
     end
 
     it "returns nil when the setting is a boolean" do
-      settings.stubs(:value).with('autosign', nil, false).returns 'true'
+      allow(settings).to receive(:value).with('autosign', nil, false).and_return('true')
 
       setting.mode = '0664'
       setting.owner = 'service'

data/spec/unit/settings/certificate_revocation_setting_spec.rb

@@ -4,7 +4,7 @@ require 'puppet/settings'
 require 'puppet/settings/certificate_revocation_setting'
 
 describe Puppet::Settings::CertificateRevocationSetting do
-  subject { described_class.new(:settings => stub('settings'), :desc => "test") }
+  subject { described_class.new(:settings => double('settings'), :desc => "test") }
 
   it "is of type :certificate_revocation" do
     expect(subject.type).to eq :certificate_revocation

data/spec/unit/settings/config_file_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/settings/config_file'
 

data/spec/unit/settings/directory_setting_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/settings'
@@ -15,18 +14,14 @@ describe Puppet::Settings::DirectorySetting do
 
   describe "when being converted to a resource" do
     before do
-      @settings = mock 'settings'
+      @settings = double('settings')
       @dir = Puppet::Settings::DirectorySetting.new(
           :settings => @settings, :desc => "eh", :name => :mydir, :section => "mysect")
-      @settings.stubs(:value).with(:mydir).returns @basepath
+      allow(@settings).to receive(:value).with(:mydir).and_return(@basepath)
     end
 
     it "should return :directory as its type" do
       expect(@dir.type).to eq(:directory)
     end
-
-
-
   end
 end
-

data/spec/unit/settings/duration_setting_spec.rb

@@ -1,11 +1,10 @@
-#!/usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/settings'
 require 'puppet/settings/duration_setting'
 
 describe Puppet::Settings::DurationSetting do
-  subject { described_class.new(:settings => mock('settings'), :desc => "test") }
+  subject { described_class.new(:settings => double('settings'), :desc => "test") }
 
   describe "when munging the setting" do
     it "should return the same value if given an integer" do

data/spec/unit/settings/enum_setting_spec.rb

@@ -19,7 +19,7 @@ describe Puppet::Settings::EnumSetting do
   end
 
   def enum_setting_allowing(*values)
-    Puppet::Settings::EnumSetting.new(:settings => mock('settings'),
+    Puppet::Settings::EnumSetting.new(:settings => double('settings'),
                                       :name => "testing",
                                       :desc => "description of testing",
                                       :values => values)

data/spec/unit/settings/environment_conf_spec.rb

@@ -5,14 +5,14 @@ describe Puppet::Settings::EnvironmentConf do
 
   def setup_environment_conf(config, conf_hash)
     conf_hash.each do |setting,value|
-      config.expects(:setting).with(setting).returns(
-        mock('setting', :value => value)
+      expect(config).to receive(:setting).with(setting).and_return(
+        double('setting', :value => value)
       )
     end
   end
 
   context "with config" do
-    let(:config) { stub('config') }
+    let(:config) { double('config') }
     let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, ["/global/modulepath"]) }
 
     it "reads a modulepath from config and does not include global_module_path" do
@@ -91,12 +91,10 @@ describe Puppet::Settings::EnvironmentConf do
   end
 
   describe "with disable_per_environment_manifest" do
-
-    let(:config) { stub('config') }
+    let(:config) { double('config') }
     let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, ["/global/modulepath"]) }
 
     context "set true" do
-
       before(:each) do
         Puppet[:default_manifest] = File.expand_path('/default/manifest')
         Puppet[:disable_per_environment_manifest] = true

data/spec/unit/settings/file_setting_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/settings'
@@ -19,13 +18,13 @@ describe Puppet::Settings::FileSetting do
         :service_group_available? => false
       }.merge(wanted_values)
 
-      settings = mock("settings")
+      settings = double("settings")
 
-      settings.stubs(:[]).with(:user).returns real_values[:user]
-      settings.stubs(:[]).with(:group).returns real_values[:group]
-      settings.stubs(:[]).with(:mkusers).returns real_values[:mkusers]
-      settings.stubs(:service_user_available?).returns real_values[:service_user_available?]
-      settings.stubs(:service_group_available?).returns real_values[:service_group_available?]
+      allow(settings).to receive(:[]).with(:user).and_return(real_values[:user])
+      allow(settings).to receive(:[]).with(:group).and_return(real_values[:group])
+      allow(settings).to receive(:[]).with(:mkusers).and_return(real_values[:mkusers])
+      allow(settings).to receive(:service_user_available?).and_return(real_values[:service_user_available?])
+      allow(settings).to receive(:service_group_available?).and_return(real_values[:service_group_available?])
 
       settings
     end
@@ -120,16 +119,16 @@ describe Puppet::Settings::FileSetting do
   end
 
   it "should be able to be converted into a resource" do
-    expect(FileSetting.new(:settings => mock("settings"), :desc => "eh")).to respond_to(:to_resource)
+    expect(FileSetting.new(:settings => double("settings"), :desc => "eh")).to respond_to(:to_resource)
   end
 
   describe "when being converted to a resource" do
     before do
       @basepath = make_absolute("/somepath")
-      @settings = mock 'settings'
+      @settings = double('settings')
       @file = Puppet::Settings::FileSetting.new(:settings => @settings, :desc => "eh", :name => :myfile, :section => "mysect")
-      @file.stubs(:create_files?).returns true
-      @settings.stubs(:value).with(:myfile, nil, false).returns @basepath
+      allow(@file).to receive(:create_files?).and_return(true)
+      allow(@settings).to receive(:value).with(:myfile, nil, false).and_return(@basepath)
     end
 
     it "should return :file as its type" do
@@ -137,29 +136,29 @@ describe Puppet::Settings::FileSetting do
     end
 
     it "should skip non-existent files if 'create_files' is not enabled" do
-      @file.expects(:create_files?).returns false
-      @file.expects(:type).returns :file
-      Puppet::FileSystem.expects(:exist?).with(@basepath).returns false
+      expect(@file).to receive(:create_files?).and_return(false)
+      expect(@file).to receive(:type).and_return(:file)
+      expect(Puppet::FileSystem).to receive(:exist?).with(@basepath).and_return(false)
       expect(@file.to_resource).to be_nil
     end
 
     it "should manage existent files even if 'create_files' is not enabled" do
-      @file.expects(:create_files?).returns false
-      @file.expects(:type).returns :file
-      Puppet::FileSystem.stubs(:exist?)
-      Puppet::FileSystem.expects(:exist?).with(@basepath).returns true
+      expect(@file).to receive(:create_files?).and_return(false)
+      expect(@file).to receive(:type).and_return(:file)
+      allow(Puppet::FileSystem).to receive(:exist?)
+      expect(Puppet::FileSystem).to receive(:exist?).with(@basepath).and_return(true)
       expect(@file.to_resource).to be_instance_of(Puppet::Resource)
     end
 
     describe "on POSIX systems", :if => Puppet.features.posix? do
       it "should skip files in /dev" do
-        @settings.stubs(:value).with(:myfile, nil, false).returns "/dev/file"
+        allow(@settings).to receive(:value).with(:myfile, nil, false).and_return("/dev/file")
         expect(@file.to_resource).to be_nil
       end
     end
 
     it "should skip files whose paths are not strings" do
-      @settings.stubs(:value).with(:myfile, nil, false).returns :foo
+      allow(@settings).to receive(:value).with(:myfile, nil, false).and_return(:foo)
       expect(@file.to_resource).to be_nil
     end
 
@@ -176,7 +175,7 @@ describe Puppet::Settings::FileSetting do
     end
 
     it "should fully qualified returned files if necessary (#795)" do
-      @settings.stubs(:value).with(:myfile, nil, false).returns "myfile"
+      allow(@settings).to receive(:value).with(:myfile, nil, false).and_return("myfile")
       path = File.expand_path('myfile')
       expect(@file.to_resource.title).to eq(path)
     end
@@ -198,80 +197,79 @@ describe Puppet::Settings::FileSetting do
     it "should not set the mode on a the file if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
 
-      @file.stubs(:mode).returns(0755)
+      allow(@file).to receive(:mode).and_return(0755)
 
       expect(@file.to_resource[:mode]).to eq(nil)
     end
 
     it "should set the owner if running as root and the owner is provided" do
       Puppet[:manage_internal_file_permissions] = true
-      Puppet.features.expects(:root?).returns true
-      Puppet.features.stubs(:microsoft_windows?).returns false
+      expect(Puppet.features).to receive(:root?).and_return(true)
+      allow(Puppet.features).to receive(:microsoft_windows?).and_return(false)
 
-      @file.stubs(:owner).returns "foo"
+      allow(@file).to receive(:owner).and_return("foo")
       expect(@file.to_resource[:owner]).to eq("foo")
     end
 
     it "should not set the owner if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
-      Puppet.features.stubs(:root?).returns true
-      @file.stubs(:owner).returns "foo"
+      allow(Puppet.features).to receive(:root?).and_return(true)
+      allow(@file).to receive(:owner).and_return("foo")
 
       expect(@file.to_resource[:owner]).to eq(nil)
     end
 
     it "should set the group if running as root and the group is provided" do
       Puppet[:manage_internal_file_permissions] = true
-      Puppet.features.expects(:root?).returns true
-      Puppet.features.stubs(:microsoft_windows?).returns false
+      expect(Puppet.features).to receive(:root?).and_return(true)
+      allow(Puppet.features).to receive(:microsoft_windows?).and_return(false)
 
-      @file.stubs(:group).returns "foo"
+      allow(@file).to receive(:group).and_return("foo")
       expect(@file.to_resource[:group]).to eq("foo")
     end
 
     it "should not set the group if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
-      Puppet.features.stubs(:root?).returns true
-      @file.stubs(:group).returns "foo"
+      allow(Puppet.features).to receive(:root?).and_return(true)
+      allow(@file).to receive(:group).and_return("foo")
 
       expect(@file.to_resource[:group]).to eq(nil)
     end
 
-
     it "should not set owner if not running as root" do
       Puppet[:manage_internal_file_permissions] = true
-      Puppet.features.expects(:root?).returns false
-      Puppet.features.stubs(:microsoft_windows?).returns false
-      @file.stubs(:owner).returns "foo"
+      expect(Puppet.features).to receive(:root?).and_return(false)
+      allow(Puppet.features).to receive(:microsoft_windows?).and_return(false)
+      allow(@file).to receive(:owner).and_return("foo")
       expect(@file.to_resource[:owner]).to be_nil
     end
 
     it "should not set group if not running as root" do
       Puppet[:manage_internal_file_permissions] = true
-      Puppet.features.expects(:root?).returns false
-      Puppet.features.stubs(:microsoft_windows?).returns false
-      @file.stubs(:group).returns "foo"
+      expect(Puppet.features).to receive(:root?).and_return(false)
+      allow(Puppet.features).to receive(:microsoft_windows?).and_return(false)
+      allow(@file).to receive(:group).and_return("foo")
       expect(@file.to_resource[:group]).to be_nil
     end
 
     describe "on Microsoft Windows systems" do
       before :each do
-        Puppet.features.stubs(:microsoft_windows?).returns true
+        allow(Puppet.features).to receive(:microsoft_windows?).and_return(true)
       end
 
       it "should not set owner" do
-        @file.stubs(:owner).returns "foo"
+        allow(@file).to receive(:owner).and_return("foo")
         expect(@file.to_resource[:owner]).to be_nil
       end
 
       it "should not set group" do
-        @file.stubs(:group).returns "foo"
+        allow(@file).to receive(:group).and_return("foo")
         expect(@file.to_resource[:group]).to be_nil
       end
     end
 
     it "should set :ensure to the file type" do
-      @file.expects(:type).returns :directory
+      expect(@file).to receive(:type).and_return(:directory)
       expect(@file.to_resource[:ensure]).to eq(:directory)
     end
 
@@ -284,7 +282,7 @@ describe Puppet::Settings::FileSetting do
     end
 
     it "should tag the resource with the settings section" do
-      @file.expects(:section).returns "mysect"
+      expect(@file).to receive(:section).and_return("mysect")
       expect(@file.to_resource).to be_tagged("mysect")
     end
 
@@ -303,7 +301,7 @@ describe Puppet::Settings::FileSetting do
 
   describe "#munge" do
     it 'does not expand the path of the special value :memory: so we can set dblocation to an in-memory database' do
-      filesetting = FileSetting.new(:settings => mock("settings"), :desc => "eh")
+      filesetting = FileSetting.new(:settings => double("settings"), :desc => "eh")
       expect(filesetting.munge(':memory:')).to eq(':memory:')
     end
   end
@@ -314,7 +312,7 @@ describe Puppet::Settings::FileSetting do
     end
 
     let(:setting) do
-      settings = mock("settings", :value => path)
+      settings = double("settings", :value => path)
       FileSetting.new(:name => :mysetting, :desc => "creates a file", :settings => settings)
     end
 

data/spec/unit/settings/path_setting_spec.rb

@@ -1,8 +1,7 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Settings::PathSetting do
-  subject { described_class.new(:settings => mock('settings'), :desc => "test") }
+  subject { described_class.new(:settings => double('settings'), :desc => "test") }
 
   context "#munge" do
     it "should expand all path elements" do

data/spec/unit/settings/priority_setting_spec.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/settings'
@@ -6,7 +5,7 @@ require 'puppet/settings/priority_setting'
 require 'puppet/util/platform'
 
 describe Puppet::Settings::PrioritySetting do
-  let(:setting) { described_class.new(:settings => mock('settings'), :desc => "test") }
+  let(:setting) { described_class.new(:settings => double('settings'), :desc => "test") }
 
   it "is of type :priority" do
     expect(setting.type).to eq(:priority)

data/spec/unit/settings/string_setting_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/settings'
@@ -8,21 +7,21 @@ describe Puppet::Settings::StringSetting do
   StringSetting = Puppet::Settings::StringSetting
 
   before(:each) do
-    @test_setting_name = :test_setting 
+    @test_setting_name = :test_setting
     @test_setting_default = "my_crazy_default/$var"
     @application_setting = "application/$var"
-    @application_defaults = { } 
+    @application_defaults = { }
     Puppet::Settings::REQUIRED_APP_SETTINGS.each do |key|
       @application_defaults[key] = "foo"
     end
     @application_defaults[:run_mode] = :user
     @settings = Puppet::Settings.new
     @application_defaults.each { |k,v| @settings.define_settings :main, k => {:default=>"", :desc => "blah"} }
-    @settings.define_settings :main, :var               => {  :default => "interpolate!", 
-                                                              :type => :string, 
+    @settings.define_settings :main, :var               => {  :default => "interpolate!",
+                                                              :type => :string,
                                                               :desc => "my var desc" },
-                                     @test_setting_name => {  :default => @test_setting_default, 
-                                                              :type => :string, 
+                                     @test_setting_name => {  :default => @test_setting_default,
+                                                              :type => :string,
                                                               :desc => "my test desc" }
     @test_setting = @settings.setting(@test_setting_name)
   end
@@ -32,40 +31,40 @@ describe Puppet::Settings::StringSetting do
       it "should return the setting default" do
         expect(@test_setting.default).to eq(@test_setting_default)
       end
-      
+
       it "should be uninterpolated" do
         expect(@test_setting.default).not_to match(/interpolate/)
       end
     end
-    
+
     describe "checking application defaults first" do
       describe "if application defaults set" do
         before(:each) do
           @settings.initialize_app_defaults @application_defaults.merge @test_setting_name => @application_setting
         end
-        
+
         it "should return the application-set default" do
           expect(@test_setting.default(true)).to eq(@application_setting)
         end
-        
+
         it "should be uninterpolated" do
           expect(@test_setting.default(true)).not_to match(/interpolate/)
         end
-        
+
       end
-      
+
       describe "if application defaults not set" do
         it "should return the regular default" do
           expect(@test_setting.default(true)).to eq(@test_setting_default)
         end
-        
+
         it "should be uninterpolated" do
           expect(@test_setting.default(true)).not_to match(/interpolate/)
         end
       end
     end
   end
-  
+
   describe "#value" do
     it "should be interpolated" do
       expect(@test_setting.value).to match(/interpolate/)