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

data/spec/unit/type/scheduled_task_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:scheduled_task), :if => Puppet.features.microsoft_windows? do
@@ -106,7 +105,7 @@ describe Puppet::Type.type(:scheduled_task), :if => Puppet.features.microsoft_wi
 
   describe 'when setting the trigger' do
     it 'should delegate to the provider to validate the trigger' do
-      described_class.defaultprovider.any_instance.expects(:validate_trigger).returns(true)
+      expect_any_instance_of(described_class.defaultprovider).to receive(:validate_trigger).and_return(true)
 
       described_class.new(
         :name    => 'Test Task',

data/spec/unit/type/selboolean_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:selboolean), "when validating attributes" do
@@ -17,12 +16,12 @@ describe Puppet::Type.type(:selboolean), "when validating values" do
   before do
     @class = Puppet::Type.type(:selboolean)
 
-    @provider_class = stub 'provider_class', :name => "fake", :suitable? => true, :supports_parameter? => true
-    @class.stubs(:defaultprovider).returns(@provider_class)
-    @class.stubs(:provider).returns(@provider_class)
+    @provider_class = double('provider_class', :name => "fake", :suitable? => true, :supports_parameter? => true)
+    allow(@class).to receive(:defaultprovider).and_return(@provider_class)
+    allow(@class).to receive(:provider).and_return(@provider_class)
 
-    @provider = stub 'provider', :class => @provider_class, :clear => nil
-    @provider_class.stubs(:new).returns(@provider)
+    @provider = double('provider', :class => @provider_class, :clear => nil)
+    allow(@provider_class).to receive(:new).and_return(@provider)
   end
 
   it "should support :on as a value to :value" do

data/spec/unit/type/selmodule_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:selmodule), "when validating attributes" do

data/spec/unit/type/service_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:service) do
@@ -27,8 +26,8 @@ end
 
 describe Puppet::Type.type(:service), "when validating attribute values" do
   before do
-    @provider = stub 'provider', :class => Puppet::Type.type(:service).defaultprovider, :clear => nil, :controllable? => false
-    Puppet::Type.type(:service).defaultprovider.stubs(:new).returns(@provider)
+    @provider = double('provider', :class => Puppet::Type.type(:service).defaultprovider, :clear => nil, :controllable? => false)
+    allow(Puppet::Type.type(:service).defaultprovider).to receive(:new).and_return(@provider)
   end
 
   it "should support :running as a value to :ensure" do
@@ -51,8 +50,9 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
 
   describe "the enable property" do
     before :each do
-      @provider.class.stubs(:supports_parameter?).returns true
+      allow(@provider.class).to receive(:supports_parameter?).and_return(true)
     end
+
     it "should support :true as a value" do
       srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :true)
       expect(srv.should(:enable)).to eq(:true)
@@ -69,14 +69,14 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
     end
 
     it "should support :manual as a value on Windows" do
-      Puppet.features.stubs(:microsoft_windows?).returns true
+      allow(Puppet.features).to receive(:microsoft_windows?).and_return(true)
 
       srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :manual)
       expect(srv.should(:enable)).to eq(:manual)
     end
 
     it "should not support :manual as a value when not on Windows" do
-      Puppet.features.stubs(:microsoft_windows?).returns false
+      allow(Puppet.features).to receive(:microsoft_windows?).and_return(false)
 
       expect { Puppet::Type.type(:service).new(:name => "yay", :enable => :manual) }.to raise_error(
         Puppet::Error,
@@ -111,29 +111,29 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
   end
 
   it "should allow setting the :enable parameter if the provider has the :enableable feature" do
-    Puppet::Type.type(:service).defaultprovider.stubs(:supports_parameter?).returns(true)
-    Puppet::Type.type(:service).defaultprovider.expects(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).returns(true)
+    allow(Puppet::Type.type(:service).defaultprovider).to receive(:supports_parameter?).and_return(true)
+    expect(Puppet::Type.type(:service).defaultprovider).to receive(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).and_return(true)
     svc = Puppet::Type.type(:service).new(:name => "yay", :enable => true)
     expect(svc.should(:enable)).to eq(:true)
   end
 
   it "should not allow setting the :enable parameter if the provider is missing the :enableable feature" do
-    Puppet::Type.type(:service).defaultprovider.stubs(:supports_parameter?).returns(true)
-    Puppet::Type.type(:service).defaultprovider.expects(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).returns(false)
+    allow(Puppet::Type.type(:service).defaultprovider).to receive(:supports_parameter?).and_return(true)
+    expect(Puppet::Type.type(:service).defaultprovider).to receive(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).and_return(false)
     svc = Puppet::Type.type(:service).new(:name => "yay", :enable => true)
     expect(svc.should(:enable)).to be_nil
   end
 
   it "should split paths on '#{File::PATH_SEPARATOR}'" do
-    Puppet::FileSystem.stubs(:exist?).returns(true)
-    FileTest.stubs(:directory?).returns(true)
+    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+    allow(FileTest).to receive(:directory?).and_return(true)
     svc = Puppet::Type.type(:service).new(:name => "yay", :path => "/one/two#{File::PATH_SEPARATOR}/three/four")
     expect(svc[:path]).to eq(%w{/one/two /three/four})
   end
 
   it "should accept arrays of paths joined by '#{File::PATH_SEPARATOR}'" do
-    Puppet::FileSystem.stubs(:exist?).returns(true)
-    FileTest.stubs(:directory?).returns(true)
+    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+    allow(FileTest).to receive(:directory?).and_return(true)
     svc = Puppet::Type.type(:service).new(:name => "yay", :path => ["/one#{File::PATH_SEPARATOR}/two", "/three#{File::PATH_SEPARATOR}/four"])
     expect(svc[:path]).to eq(%w{/one /two /three /four})
   end
@@ -141,11 +141,11 @@ end
 
 describe Puppet::Type.type(:service), "when setting default attribute values" do
   it "should default to the provider's default path if one is available" do
-    FileTest.stubs(:directory?).returns(true)
-    Puppet::FileSystem.stubs(:exist?).returns(true)
+    allow(FileTest).to receive(:directory?).and_return(true)
+    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
 
-    Puppet::Type.type(:service).defaultprovider.stubs(:respond_to?).returns(true)
-    Puppet::Type.type(:service).defaultprovider.stubs(:defpath).returns("testing")
+    allow(Puppet::Type.type(:service).defaultprovider).to receive(:respond_to?).and_return(true)
+    allow(Puppet::Type.type(:service).defaultprovider).to receive(:defpath).and_return("testing")
     svc = Puppet::Type.type(:service).new(:name => "other")
     expect(svc[:path]).to eq(["testing"])
   end
@@ -161,8 +161,8 @@ describe Puppet::Type.type(:service), "when setting default attribute values" do
   end
 
   it "should default 'control' to the upcased service name with periods replaced by underscores if the provider supports the 'controllable' feature" do
-    provider = stub 'provider', :controllable? => true, :class => Puppet::Type.type(:service).defaultprovider, :clear => nil
-    Puppet::Type.type(:service).defaultprovider.stubs(:new).returns(provider)
+    provider = double('provider', :controllable? => true, :class => Puppet::Type.type(:service).defaultprovider, :clear => nil)
+    allow(Puppet::Type.type(:service).defaultprovider).to receive(:new).and_return(provider)
     svc = Puppet::Type.type(:service).new(:name => "nfs.client")
     expect(svc[:control]).to eq("NFS_CLIENT_START")
   end
@@ -174,14 +174,14 @@ describe Puppet::Type.type(:service), "when retrieving the host's current state"
   end
 
   it "should use the provider's status to determine whether the service is running" do
-    @service.provider.expects(:status).returns(:yepper)
+    expect(@service.provider).to receive(:status).and_return(:yepper)
     @service[:ensure] = :running
     expect(@service.property(:ensure).retrieve).to eq(:yepper)
   end
 
   it "should ask the provider whether it is enabled" do
-    @service.provider.class.stubs(:supports_parameter?).returns(true)
-    @service.provider.expects(:enabled?).returns(:yepper)
+    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
+    expect(@service.provider).to receive(:enabled?).and_return(:yepper)
     @service[:enable] = true
     expect(@service.property(:enable).retrieve).to eq(:yepper)
   end
@@ -194,56 +194,56 @@ describe Puppet::Type.type(:service), "when changing the host" do
 
   it "should start the service if it is supposed to be running" do
     @service[:ensure] = :running
-    @service.provider.expects(:start)
+    expect(@service.provider).to receive(:start)
     @service.property(:ensure).sync
   end
 
   it "should stop the service if it is supposed to be stopped" do
     @service[:ensure] = :stopped
-    @service.provider.expects(:stop)
+    expect(@service.provider).to receive(:stop)
     @service.property(:ensure).sync
   end
 
   it "should enable the service if it is supposed to be enabled" do
-    @service.provider.class.stubs(:supports_parameter?).returns(true)
+    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
     @service[:enable] = true
-    @service.provider.expects(:enable)
+    expect(@service.provider).to receive(:enable)
     @service.property(:enable).sync
   end
 
   it "should disable the service if it is supposed to be disabled" do
-    @service.provider.class.stubs(:supports_parameter?).returns(true)
+    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
     @service[:enable] = false
-    @service.provider.expects(:disable)
+    expect(@service.provider).to receive(:disable)
     @service.property(:enable).sync
   end
 
   it "should always consider the enable state of a static service to be in sync" do
-    @service.provider.class.stubs(:supports_parameter?).returns(true)
-    @service.provider.expects(:cached_enabled?).returns('static')
+    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
+    expect(@service.provider).to receive(:cached_enabled?).and_return('static')
     @service[:enable] = false
-    Puppet.expects(:debug).with("Unable to enable or disable static service yay")
+    expect(Puppet).to receive(:debug).with("Unable to enable or disable static service yay")
     expect(@service.property(:enable).insync?(:true)).to eq(true)
   end
 
   it "should determine insyncness normally when the service is not static" do
-    @service.provider.class.stubs(:supports_parameter?).returns(true)
-    @service.provider.expects(:cached_enabled?).returns('true')
+    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
+    expect(@service.provider).to receive(:cached_enabled?).and_return('true')
     @service[:enable] = true
-    Puppet.expects(:debug).never
+    expect(Puppet).not_to receive(:debug)
     expect(@service.property(:enable).insync?(:true)).to eq(true)
   end
 
   it "should sync the service's enable state when changing the state of :ensure if :enable is being managed" do
-    @service.provider.class.stubs(:supports_parameter?).returns(true)
+    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
     @service[:enable] = false
     @service[:ensure] = :stopped
 
-    @service.property(:enable).expects(:retrieve).returns("whatever")
-    @service.property(:enable).expects(:insync?).returns(false)
-    @service.property(:enable).expects(:sync)
+    expect(@service.property(:enable)).to receive(:retrieve).and_return("whatever")
+    expect(@service.property(:enable)).to receive(:insync?).and_return(false)
+    expect(@service.property(:enable)).to receive(:sync)
 
-    @service.provider.stubs(:stop)
+    allow(@service.provider).to receive(:stop)
 
     @service.property(:ensure).sync
   end
@@ -256,27 +256,27 @@ describe Puppet::Type.type(:service), "when refreshing the service" do
 
   it "should restart the service if it is running" do
     @service[:ensure] = :running
-    @service.provider.expects(:status).returns(:running)
-    @service.provider.expects(:restart)
+    expect(@service.provider).to receive(:status).and_return(:running)
+    expect(@service.provider).to receive(:restart)
     @service.refresh
   end
 
   it "should restart the service if it is running, even if it is supposed to stopped" do
     @service[:ensure] = :stopped
-    @service.provider.expects(:status).returns(:running)
-    @service.provider.expects(:restart)
+    expect(@service.provider).to receive(:status).and_return(:running)
+    expect(@service.provider).to receive(:restart)
     @service.refresh
   end
 
   it "should not restart the service if it is not running" do
     @service[:ensure] = :running
-    @service.provider.expects(:status).returns(:stopped)
+    expect(@service.provider).to receive(:status).and_return(:stopped)
     @service.refresh
   end
 
   it "should add :ensure as a property if it is not being managed" do
-    @service.provider.expects(:status).returns(:running)
-    @service.provider.expects(:restart)
+    expect(@service.provider).to receive(:status).and_return(:running)
+    expect(@service.provider).to receive(:restart)
     @service.refresh
   end
 end

data/spec/unit/type/ssh_authorized_key_spec.rb

@@ -1,17 +1,15 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
-
 describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
 
   before do
-    provider_class = stub 'provider_class', :name => "fake", :suitable? => true, :supports_parameter? => true
-    described_class.stubs(:defaultprovider).returns(provider_class)
-    described_class.stubs(:provider).returns(provider_class)
+    provider_class = double('provider_class', :name => "fake", :suitable? => true, :supports_parameter? => true)
+    allow(described_class).to receive(:defaultprovider).and_return(provider_class)
+    allow(described_class).to receive(:provider).and_return(provider_class)
 
-    provider = stub 'provider', :class => provider_class, :file_path => make_absolute("/tmp/whatever"), :clear => nil
-    provider_class.stubs(:new).returns(provider)
+    provider = double('provider', :class => provider_class, :file_path => make_absolute("/tmp/whatever"), :clear => nil)
+    allow(provider_class).to receive(:new).and_return(provider)
   end
 
   it "has :name as its namevar" do
@@ -19,7 +17,6 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
   end
 
   describe "when validating attributes" do
-
     [:name, :provider].each do |param|
       it "has a #{param} parameter" do
         expect(described_class.attrtype(param)).to eq :param
@@ -31,13 +28,10 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
         expect(described_class.attrtype(property)).to eq :property
       end
     end
-
   end
 
   describe "when validating values" do
-
     describe "for name" do
-
       it "supports valid names" do
         described_class.new(:name => "username", :ensure => :present, :user => "nobody")
         described_class.new(:name => "username@hostname", :ensure => :present, :user => "nobody")
@@ -46,11 +40,9 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
       it "supports whitespace" do
         described_class.new(:name => "my test", :ensure => :present, :user => "nobody")
       end
-
     end
 
     describe "for ensure" do
-
       it "supports :present" do
         described_class.new(:name => "whev", :ensure => :present, :user => "nobody")
       end
@@ -62,11 +54,9 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
       it "nots support other values" do
         expect { described_class.new(:name => "whev", :ensure => :foo, :user => "nobody") }.to raise_error(Puppet::Error, /Invalid value/)
       end
-
     end
 
     describe "for type" do
-
       [
         :'ssh-dss', :dsa,
         :'ssh-rsa', :rsa,
@@ -93,11 +83,9 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
       it "doesn't support values other than ssh-dss, ssh-rsa, dsa, rsa" do
         expect { described_class.new(:name => "whev", :type => :something) }.to raise_error(Puppet::Error,/Invalid value/)
       end
-
     end
 
     describe "for key" do
-
       it "supports a valid key like a 1024 bit rsa key" do
         expect { described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :key => 'AAAAB3NzaC1yc2EAAAADAQABAAAAgQDCPfzW2ry7XvMc6E5Kj2e5fF/YofhKEvsNMUogR3PGL/HCIcBlsEjKisrY0aYgD8Ikp7ZidpXLbz5dBsmPy8hJiBWs5px9ZQrB/EOQAwXljvj69EyhEoGawmxQMtYw+OAIKHLJYRuk1QiHAMHLp5piqem8ZCV2mLb9AsJ6f7zUVw==')}.to_not raise_error
       end
@@ -113,11 +101,9 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
       it "doesn't support whitespaces" do
         expect { described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :key => 'AAA FA==')}.to raise_error(Puppet::Error,/Key must not contain whitespace/)
       end
-
     end
 
     describe "for options" do
-
       it "supports flags as options" do
         expect { described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'cert-authority')}.to_not raise_error
         expect { described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'no-port-forwarding')}.to_not raise_error
@@ -156,11 +142,9 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
         resource = described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => ["a","b","c"])
         expect(resource.property(:options).should_to_s(["a","b","c"])).to eq "['a', 'b', 'c']"
       end
-
     end
 
     describe "for user" do
-
       it "supports present users" do
         described_class.new(:name => "whev", :type => :rsa, :user => "root")
       end
@@ -168,11 +152,9 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
       it "supports absent users" do
         described_class.new(:name => "whev", :type => :rsa, :user => "ihopeimabsent")
       end
-
     end
 
     describe "for target" do
-
       it "supports absolute paths" do
         described_class.new(:name => "whev", :type => :rsa, :target => "/tmp/here")
       end
@@ -190,13 +172,10 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
         described_class.new(:name => "whev", :user => 'idontexist').should(:target)
         expect(@logs.map(&:message)).to include("The required user is not yet present on the system")
       end
-
     end
-
   end
 
   describe "when neither user nor target is specified" do
-
     it "raises an error" do
       expect do
         described_class.new(
@@ -206,11 +185,9 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
           :ensure => :present)
       end.to raise_error(Puppet::Error,/user.*or.*target.*mandatory/)
     end
-
   end
 
   describe "when both target and user are specified" do
-
     it "uses target" do
       resource = described_class.new(
         :name => "Test",
@@ -219,12 +196,9 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
       )
       expect(resource.should(:target)).to eq "/tmp/blah"
     end
-
   end
 
-
   describe "when user is specified" do
-
     it "determines target" do
       resource = described_class.new(
         :name   => "Test",
@@ -240,11 +214,9 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
       target = File.expand_path("~root/.ssh/authorized_keys")
       expect(resource.property(:target).safe_insync?(target)).to eq true
     end
-
   end
 
   describe "when calling validate" do
-
     it "doesn't crash on a non-existent user" do
       resource = described_class.new(
         :name   => "Test",
@@ -252,7 +224,5 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
       )
       resource.validate
     end
-
   end
-
 end

data/spec/unit/type/sshkey_spec.rb

@@ -1,7 +1,5 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
-
 describe Puppet::Type.type(:sshkey) do
 
   it "uses :name as its namevar" do