puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/type/k5login_spec.rb

@@ -46,7 +46,7 @@ describe Puppet::Type.type(:k5login), :unless => Puppet.features.microsoft_windo
 
       it "should create the file when synced" do
         resource(:ensure => 'present').parameter(:ensure).sync
-        Puppet::FileSystem::File.exist?(path).should be_true
+        Puppet::FileSystem.exist?(path).should be_true
       end
     end
 
@@ -83,7 +83,7 @@ describe Puppet::Type.type(:k5login), :unless => Puppet.features.microsoft_windo
 
       it "should remove the file ensure is absent" do
         resource(:ensure => 'absent').property(:ensure).sync
-        Puppet::FileSystem::File.exist?(path).should be_false
+        Puppet::FileSystem.exist?(path).should be_false
       end
 
       it "should write one principal to the file" do
@@ -106,7 +106,7 @@ describe Puppet::Type.type(:k5login), :unless => Puppet.features.microsoft_windo
           it "should update the mode to #{mode}" do
             resource(:mode => mode).property(:mode).sync
 
-            (Puppet::FileSystem::File.new(path).stat.mode & 07777).to_s(8).should == mode
+            (Puppet::FileSystem.stat(path).mode & 07777).to_s(8).should == mode
           end
         end
       end

data/spec/unit/type/nagios_spec.rb

@@ -258,6 +258,12 @@ describe "Nagios resource types" do
         puppet_type.attrclass(:target).instance_variable_get("@doc").should_not be_nil
       end
 
+      [ :owner, :group, :mode ].each do |fileprop|
+        it "should have a #{fileprop} parameter" do
+          puppet_type.parameters.should be_include(fileprop)
+        end
+      end
+
       nagios_type.parameters.reject { |param| param == nagios_type.namevar or param.to_s =~ /^[0-9]/ }.each do |param|
         it "should have a #{param} property" do
           puppet_type.should be_validproperty(param)

data/spec/unit/type/package/package_settings_spec.rb

@@ -0,0 +1,135 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+describe Puppet::Type.type(:package) do
+
+  before do
+    Puppet::Util::Storage.stubs(:store)
+  end
+
+  it "should have a :package_settings feature that requires :package_settings_insync?, :package_settings and :package_settings=" do
+    described_class.provider_feature(:package_settings).methods.should == [:package_settings_insync?, :package_settings, :package_settings=]
+  end
+
+  context "when validating attributes" do
+    it "should have a package_settings property" do
+      described_class.attrtype(:package_settings).should == :property
+    end
+  end
+
+  context "when validating attribute values" do
+    let(:provider) do
+      stub( 'provider',
+            :class => described_class.defaultprovider,
+            :clear => nil,
+            :validate_source => false )
+    end
+    before do
+      provider.class.stubs(:supports_parameter?).returns(true)
+      described_class.defaultprovider.stubs(:new).returns(provider)
+    end
+    describe 'package_settings' do
+      context "with a minimalistic provider supporting package_settings" do
+        context "and {:package_settings => :settings}" do
+          let(:resource) do 
+            described_class.new :name => 'foo', :package_settings => :settings
+          end
+          it { expect { resource }.to_not raise_error }
+          it "should set package_settings to :settings" do
+            resource.value(:package_settings).should be :settings
+          end
+        end
+      end
+      context "with a provider that supports validation of the package_settings" do
+        context "and {:package_settings => :valid_value}" do
+          before do
+            provider.expects(:package_settings_validate).once.with(:valid_value).returns(true)
+          end
+          let(:resource) do 
+            described_class.new :name => 'foo', :package_settings => :valid_value
+          end
+          it { expect { resource }.to_not raise_error }
+          it "should set package_settings to :valid_value" do
+            resource.value(:package_settings).should == :valid_value
+          end
+        end
+        context "and {:package_settings => :invalid_value}" do
+          before do
+            msg = "package_settings must be a Hash, not Symbol"
+            provider.expects(:package_settings_validate).once.
+              with(:invalid_value).raises(ArgumentError, msg)
+          end
+          let(:resource) do 
+            described_class.new :name => 'foo', :package_settings => :invalid_value
+          end
+          it do
+            expect { resource }.to raise_error Puppet::Error,
+              /package_settings must be a Hash, not Symbol/
+          end
+        end
+      end
+      context "with a provider that supports munging of the package_settings" do
+        context "and {:package_settings => 'A'}" do
+          before do
+            provider.expects(:package_settings_munge).once.with('A').returns(:a)
+          end
+          let(:resource) do 
+            described_class.new :name => 'foo', :package_settings => 'A'
+          end
+          it do
+            expect { resource }.to_not raise_error 
+          end
+          it "should set package_settings to :a" do
+            resource.value(:package_settings).should be :a
+          end
+        end
+      end
+    end
+  end
+  describe "package_settings property" do
+    let(:provider) do
+      stub( 'provider',
+            :class => described_class.defaultprovider,
+            :clear => nil,
+            :validate_source => false )
+    end
+    before do
+      provider.class.stubs(:supports_parameter?).returns(true)
+      described_class.defaultprovider.stubs(:new).returns(provider)
+    end
+    context "with {package_settings => :should}" do
+      let(:resource) do 
+        described_class.new :name => 'foo', :package_settings => :should
+      end
+      describe "#insync?(:is)" do
+        it "returns the result of provider.package_settings_insync?(:should,:is)" do
+          resource.provider.expects(:package_settings_insync?).once.with(:should,:is).returns :ok1
+          resource.property(:package_settings).insync?(:is).should be :ok1
+        end
+      end
+      describe "#should_to_s(:newvalue)" do
+        it "returns the result of provider.package_settings_should_to_s(:should,:newvalue)" do
+          resource.provider.expects(:package_settings_should_to_s).once.with(:should,:newvalue).returns :ok2
+          resource.property(:package_settings).should_to_s(:newvalue).should be :ok2
+        end
+      end
+      describe "#is_to_s(:currentvalue)" do
+        it "returns the result of provider.package_settings_is_to_s(:should,:currentvalue)" do
+          resource.provider.expects(:package_settings_is_to_s).once.with(:should,:currentvalue).returns :ok3
+          resource.property(:package_settings).is_to_s(:currentvalue).should be :ok3
+        end
+      end
+    end
+    context "with any non-nil package_settings" do
+      describe "#change_to_s(:currentvalue,:newvalue)" do
+        let(:resource) do 
+          described_class.new :name => 'foo', :package_settings => {}
+        end
+        it "returns the result of provider.package_settings_change_to_s(:currentvalue,:newvalue)" do
+          resource.provider.expects(:package_settings_change_to_s).once.with(:currentvalue,:newvalue).returns :ok4
+          resource.property(:package_settings).change_to_s(:currentvalue,:newvalue).should be :ok4
+        end
+      end
+    end
+  end
+end

data/spec/unit/type/package_spec.rb

@@ -26,6 +26,10 @@ describe Puppet::Type.type(:package) do
     Puppet::Type.type(:package).provider_feature(:versionable).should_not be_nil
   end
 
+  it "should have a :package_settings feature that requires :package_settings_insync?, :package_settings and :package_settings=" do
+    Puppet::Type.type(:package).provider_feature(:package_settings).methods.should == [:package_settings_insync?, :package_settings, :package_settings=]
+  end
+
   it "should default to being installed" do
     pkg = Puppet::Type.type(:package).new(:name => "yay", :provider => :apt)
     pkg.should(:ensure).should == :present
@@ -41,10 +45,14 @@ describe Puppet::Type.type(:package) do
     it "should have an ensure property" do
       Puppet::Type.type(:package).attrtype(:ensure).should == :property
     end
+
+    it "should have a package_settings property" do
+      Puppet::Type.type(:package).attrtype(:package_settings).should == :property
+    end
   end
 
   describe "when validating attribute values" do
-    before do
+    before :each do
       @provider = stub(
         'provider',
         :class           => Puppet::Type.type(:package).defaultprovider,
@@ -54,6 +62,10 @@ describe Puppet::Type.type(:package) do
       Puppet::Type.type(:package).defaultprovider.stubs(:new).returns(@provider)
     end
 
+    after :each do
+      Puppet::Type.type(:package).defaultprovider = nil
+    end
+
     it "should support :present as a value to :ensure" do
       Puppet::Type.type(:package).new(:name => "yay", :ensure => :present)
     end

data/spec/unit/type/resources_spec.rb

@@ -51,6 +51,161 @@ describe resources do
     end
   end
 
+  describe "#check_user purge behaviour" do
+    describe "with unless_system_user => true" do
+      before do
+        @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_system_user => true
+        @res.catalog = Puppet::Resource::Catalog.new
+      end
+
+      it "should never purge hardcoded system users" do
+        %w{root nobody bin noaccess daemon sys}.each do |sys_user|
+          @res.user_check(Puppet::Type.type(:user).new(:name => sys_user)).should be_false
+        end
+      end
+
+      it "should not purge system users if unless_system_user => true" do
+        user_hash = {:name => 'system_user', :uid => 125, :system => true}
+        user = Puppet::Type.type(:user).new(user_hash)
+        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        @res.user_check(user).should be_false
+      end
+
+      it "should purge manual users if unless_system_user => true" do
+        user_hash = {:name => 'system_user', :uid => 525, :system => true}
+        user = Puppet::Type.type(:user).new(user_hash)
+        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        @res.user_check(user).should be_true
+      end
+
+      it "should purge system users over 500 if unless_system_user => 600" do
+        res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_system_user => 600
+        res.catalog = Puppet::Resource::Catalog.new
+        user_hash = {:name => 'system_user', :uid => 525, :system => true}
+        user = Puppet::Type.type(:user).new(user_hash)
+        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        res.user_check(user).should be_false
+      end
+    end
+
+    describe "with unless_uid" do
+      describe "with a uid range" do
+        before do
+          @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => 10_000..20_000
+          @res.catalog = Puppet::Resource::Catalog.new
+        end
+
+        it "should purge uids that are not in a specified range" do
+          user_hash = {:name => 'special_user', :uid => 25_000}
+          user = Puppet::Type.type(:user).new(user_hash)
+          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          @res.user_check(user).should be_true
+        end
+
+        it "should not purge uids that are in a specified range" do
+          user_hash = {:name => 'special_user', :uid => 15_000}
+          user = Puppet::Type.type(:user).new(user_hash)
+          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          @res.user_check(user).should be_false
+        end
+      end
+
+      describe "with a uid range array" do
+        before do
+          @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => [10_000..15_000, 15_000..20_000]
+          @res.catalog = Puppet::Resource::Catalog.new
+        end
+
+        it "should purge uids that are not in a specified range array" do
+          user_hash = {:name => 'special_user', :uid => 25_000}
+          user = Puppet::Type.type(:user).new(user_hash)
+          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          @res.user_check(user).should be_true
+        end
+
+        it "should not purge uids that are in a specified range array" do
+          user_hash = {:name => 'special_user', :uid => 15_000}
+          user = Puppet::Type.type(:user).new(user_hash)
+          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          @res.user_check(user).should be_false
+        end
+
+      end
+
+      describe "with a uid array" do
+        before do
+          @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => [15_000, 15_001, 15_002]
+          @res.catalog = Puppet::Resource::Catalog.new
+        end
+
+        it "should purge uids that are not in a specified array" do
+          user_hash = {:name => 'special_user', :uid => 25_000}
+          user = Puppet::Type.type(:user).new(user_hash)
+          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          @res.user_check(user).should be_true
+        end
+
+        it "should not purge uids that are in a specified array" do
+          user_hash = {:name => 'special_user', :uid => 15000}
+          user = Puppet::Type.type(:user).new(user_hash)
+          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          @res.user_check(user).should be_false
+        end
+
+      end
+
+      describe "with a single uid" do
+        before do
+          @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => 15_000
+          @res.catalog = Puppet::Resource::Catalog.new
+        end
+
+        it "should purge uids that are not specified" do
+          user_hash = {:name => 'special_user', :uid => 25_000}
+          user = Puppet::Type.type(:user).new(user_hash)
+          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          @res.user_check(user).should be_true
+        end
+
+        it "should not purge uids that are specified" do
+          user_hash = {:name => 'special_user', :uid => 15_000}
+          user = Puppet::Type.type(:user).new(user_hash)
+          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          @res.user_check(user).should be_false
+        end
+      end
+
+      describe "with a mixed uid array" do
+        before do
+          @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => [10_000..15_000, 16_666]
+          @res.catalog = Puppet::Resource::Catalog.new
+        end
+
+        it "should not purge ids in the range" do
+          user_hash = {:name => 'special_user', :uid => 15_000}
+          user = Puppet::Type.type(:user).new(user_hash)
+          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          @res.user_check(user).should be_false
+        end
+
+        it "should not purge specified ids" do
+          user_hash = {:name => 'special_user', :uid => 16_666}
+          user = Puppet::Type.type(:user).new(user_hash)
+          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          @res.user_check(user).should be_false
+        end
+
+        it "should purge unspecified ids" do
+          user_hash = {:name => 'special_user', :uid => 17_000}
+          user = Puppet::Type.type(:user).new(user_hash)
+          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          @res.user_check(user).should be_true
+        end
+      end
+      
+    end
+  end
+
   describe "#generate" do
     before do
       @host1 = Puppet::Type.type(:host).new(:name => 'localhost', :ip => '127.0.0.1')

data/spec/unit/type/service_spec.rb

@@ -120,14 +120,14 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
   end
 
   it "should split paths on '#{File::PATH_SEPARATOR}'" do
-    Puppet::FileSystem::File.stubs(:exist?).returns(true)
+    Puppet::FileSystem.stubs(:exist?).returns(true)
     FileTest.stubs(:directory?).returns(true)
     svc = Puppet::Type.type(:service).new(:name => "yay", :path => "/one/two#{File::PATH_SEPARATOR}/three/four")
     svc[:path].should == %w{/one/two /three/four}
   end
 
   it "should accept arrays of paths joined by '#{File::PATH_SEPARATOR}'" do
-    Puppet::FileSystem::File.stubs(:exist?).returns(true)
+    Puppet::FileSystem.stubs(:exist?).returns(true)
     FileTest.stubs(:directory?).returns(true)
     svc = Puppet::Type.type(:service).new(:name => "yay", :path => ["/one#{File::PATH_SEPARATOR}/two", "/three#{File::PATH_SEPARATOR}/four"])
     svc[:path].should == %w{/one /two /three /four}
@@ -137,7 +137,7 @@ 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::File.stubs(:exist?).returns(true)
+    Puppet::FileSystem.stubs(:exist?).returns(true)
 
     Puppet::Type.type(:service).defaultprovider.stubs(:respond_to?).returns(true)
     Puppet::Type.type(:service).defaultprovider.stubs(:defpath).returns("testing")

data/spec/unit/type/ssh_authorized_key_spec.rb

@@ -1,38 +1,34 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-ssh_authorized_key = Puppet::Type.type(:ssh_authorized_key)
 
-describe ssh_authorized_key, :unless => Puppet.features.microsoft_windows? do
+describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
 
   before do
-    @class = Puppet::Type.type(:ssh_authorized_key)
+    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 = stub 'provider_class', :name => "fake", :suitable? => true, :supports_parameter? => true
-    @class.stubs(:defaultprovider).returns(@provider_class)
-    @class.stubs(:provider).returns(@provider_class)
-
-    @provider = stub 'provider', :class => @provider_class, :file_path => make_absolute("/tmp/whatever"), :clear => nil
-    @provider_class.stubs(:new).returns(@provider)
-    @catalog = Puppet::Resource::Catalog.new
+    provider = stub 'provider', :class => provider_class, :file_path => make_absolute("/tmp/whatever"), :clear => nil
+    provider_class.stubs(:new).returns(provider)
   end
 
-  it "should have :name be its namevar" do
-    @class.key_attributes.should == [:name]
+  it "has :name as its namevar" do
+    expect(described_class.key_attributes).to eq [:name]
   end
 
   describe "when validating attributes" do
 
     [:name, :provider].each do |param|
-      it "should have a #{param} parameter" do
-        @class.attrtype(param).should == :param
+      it "has a #{param} parameter" do
+        expect(described_class.attrtype(param)).to eq :param
       end
     end
 
     [:type, :key, :user, :target, :options, :ensure].each do |property|
-      it "should have a #{property} property" do
-        @class.attrtype(property).should == :property
+      it "has a #{property} property" do
+        expect(described_class.attrtype(property)).to eq :property
       end
     end
 
@@ -42,149 +38,156 @@ describe ssh_authorized_key, :unless => Puppet.features.microsoft_windows? do
 
     describe "for name" do
 
-      it "should support valid names" do
-        proc { @class.new(:name => "username", :ensure => :present, :user => "nobody") }.should_not raise_error
-        proc { @class.new(:name => "username@hostname", :ensure => :present, :user => "nobody") }.should_not raise_error
+      it "supports valid names" do
+        described_class.new(:name => "username", :ensure => :present, :user => "nobody")
+        described_class.new(:name => "username@hostname", :ensure => :present, :user => "nobody")
       end
 
-      it "should support whitespace" do
-        proc { @class.new(:name => "my test", :ensure => :present, :user => "nobody") }.should_not raise_error
+      it "supports whitespace" do
+        described_class.new(:name => "my test", :ensure => :present, :user => "nobody")
       end
 
     end
 
     describe "for ensure" do
 
-      it "should support :present" do
-        proc { @class.new(:name => "whev", :ensure => :present, :user => "nobody") }.should_not raise_error
+      it "supports :present" do
+        described_class.new(:name => "whev", :ensure => :present, :user => "nobody")
       end
 
-      it "should support :absent" do
-        proc { @class.new(:name => "whev", :ensure => :absent, :user => "nobody") }.should_not raise_error
+      it "supports :absent" do
+        described_class.new(:name => "whev", :ensure => :absent, :user => "nobody")
       end
 
-      it "should not support other values" do
-        proc { @class.new(:name => "whev", :ensure => :foo, :user => "nobody") }.should raise_error(Puppet::Error, /Invalid value/)
+      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', :'ssh-rsa', :rsa, :dsa, :'ecdsa-sha2-nistp256', :'ecdsa-sha2-nistp384', :'ecdsa-sha2-nistp521'].each do |keytype|
-        it "should support #{keytype}" do
-          proc { @class.new(:name => "whev", :type => keytype, :user => "nobody") }.should_not raise_error
+      [
+        :'ssh-dss', :dsa,
+        :'ssh-rsa', :rsa,
+        :'ecdsa-sha2-nistp256',
+        :'ecdsa-sha2-nistp384',
+        :'ecdsa-sha2-nistp521',
+        :ed25519, :'ssh-ed25519',
+      ].each do |keytype|
+        it "supports #{keytype}" do
+          described_class.new(:name => "whev", :type => keytype, :user => "nobody")
         end
       end
 
-      it "should alias :rsa to :ssh-rsa" do
-        key = @class.new(:name => "whev", :type => :rsa, :user => "nobody")
-        key.should(:type).should == :'ssh-rsa'
+      it "aliases :rsa to :ssh-rsa" do
+        key = described_class.new(:name => "whev", :type => :rsa, :user => "nobody")
+        expect(key.should(:type)).to eq :'ssh-rsa'
       end
 
-      it "should alias :dsa to :ssh-dss" do
-        key = @class.new(:name => "whev", :type => :dsa, :user => "nobody")
-        key.should(:type).should == :'ssh-dss'
+      it "aliases :dsa to :ssh-dss" do
+        key = described_class.new(:name => "whev", :type => :dsa, :user => "nobody")
+        expect(key.should(:type)).to eq :'ssh-dss'
       end
 
-      it "should not support values other than ssh-dss, ssh-rsa, dsa, rsa" do
-        proc { @class.new(:name => "whev", :type => :something) }.should raise_error(Puppet::Error,/Invalid value/)
+      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 "should support a valid key like a 1024 bit rsa key" do
-        proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody", :key => 'AAAAB3NzaC1yc2EAAAADAQABAAAAgQDCPfzW2ry7XvMc6E5Kj2e5fF/YofhKEvsNMUogR3PGL/HCIcBlsEjKisrY0aYgD8Ikp7ZidpXLbz5dBsmPy8hJiBWs5px9ZQrB/EOQAwXljvj69EyhEoGawmxQMtYw+OAIKHLJYRuk1QiHAMHLp5piqem8ZCV2mLb9AsJ6f7zUVw==')}.should_not raise_error
+      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
 
-      it "should support a valid key like a 4096 bit rsa key" do
-        proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody", :key => 'AAAAB3NzaC1yc2EAAAADAQABAAACAQDEY4pZFyzSfRc9wVWI3DfkgT/EL033UZm/7x1M+d+lBD00qcpkZ6CPT7lD3Z+vylQlJ5S8Wcw6C5Smt6okZWY2WXA9RCjNJMIHQbJAzwuQwgnwU/1VMy9YPp0tNVslg0sUUgpXb13WW4mYhwxyGmIVLJnUrjrQmIFhtfHsJAH8ZVqCWaxKgzUoC/YIu1u1ScH93lEdoBPLlwm6J0aiM7KWXRb7Oq1nEDZtug1zpX5lhgkQWrs0BwceqpUbY+n9sqeHU5e7DCyX/yEIzoPRW2fe2Gx1Iq6JKM/5NNlFfaW8rGxh3Z3S1NpzPHTRjw8js3IeGiV+OPFoaTtM1LsWgPDSBlzIdyTbSQR7gKh0qWYCNV/7qILEfa0yIFB5wIo4667iSPZw2pNgESVtenm8uXyoJdk8iWQ4mecdoposV/znknNb2GPgH+n/2vme4btZ0Sl1A6rev22GQjVgbWOn8zaDglJ2vgCN1UAwmq41RXprPxENGeLnWQppTnibhsngu0VFllZR5kvSIMlekLRSOFLFt92vfd+tk9hZIiKm9exxcbVCGGQPsf6dZ27rTOmg0xM2Sm4J6RRKuz79HQgA4Eg18+bqRP7j/itb89DmtXEtoZFAsEJw8IgIfeGGDtHTkfAlAC92mtK8byeaxGq57XCTKbO/r5gcOMElZHy1AcB8kw==')}.should_not raise_error
+      it "supports a valid key like a 4096 bit rsa key" do
+        expect { described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :key => 'AAAAB3NzaC1yc2EAAAADAQABAAACAQDEY4pZFyzSfRc9wVWI3DfkgT/EL033UZm/7x1M+d+lBD00qcpkZ6CPT7lD3Z+vylQlJ5S8Wcw6C5Smt6okZWY2WXA9RCjNJMIHQbJAzwuQwgnwU/1VMy9YPp0tNVslg0sUUgpXb13WW4mYhwxyGmIVLJnUrjrQmIFhtfHsJAH8ZVqCWaxKgzUoC/YIu1u1ScH93lEdoBPLlwm6J0aiM7KWXRb7Oq1nEDZtug1zpX5lhgkQWrs0BwceqpUbY+n9sqeHU5e7DCyX/yEIzoPRW2fe2Gx1Iq6JKM/5NNlFfaW8rGxh3Z3S1NpzPHTRjw8js3IeGiV+OPFoaTtM1LsWgPDSBlzIdyTbSQR7gKh0qWYCNV/7qILEfa0yIFB5wIo4667iSPZw2pNgESVtenm8uXyoJdk8iWQ4mecdoposV/znknNb2GPgH+n/2vme4btZ0Sl1A6rev22GQjVgbWOn8zaDglJ2vgCN1UAwmq41RXprPxENGeLnWQppTnibhsngu0VFllZR5kvSIMlekLRSOFLFt92vfd+tk9hZIiKm9exxcbVCGGQPsf6dZ27rTOmg0xM2Sm4J6RRKuz79HQgA4Eg18+bqRP7j/itb89DmtXEtoZFAsEJw8IgIfeGGDtHTkfAlAC92mtK8byeaxGq57XCTKbO/r5gcOMElZHy1AcB8kw==')}.to_not raise_error
       end
 
-      it "should support a valid key like a 1024 bit dsa key" do
-        proc { @class.new(:name => "whev", :type => :dsa, :user => "nobody", :key => 'AAAAB3NzaC1kc3MAAACBAI80iR78QCgpO4WabVqHHdEDigOjUEHwIjYHIubR/7u7DYrXY+e+TUmZ0CVGkiwB/0yLHK5dix3Y/bpj8ZiWCIhFeunnXccOdE4rq5sT2V3l1p6WP33RpyVYbLmeuHHl5VQ1CecMlca24nHhKpfh6TO/FIwkMjghHBfJIhXK+0w/AAAAFQDYzLupuMY5uz+GVrcP+Kgd8YqMmwAAAIB3SVN71whLWjFPNTqGyyIlMy50624UfNOaH4REwO+Of3wm/cE6eP8n75vzTwQGBpJX3BPaBGW1S1Zp/DpTOxhCSAwZzAwyf4WgW7YyAOdxN3EwTDJZeyiyjWMAOjW9/AOWt9gtKg0kqaylbMHD4kfiIhBzo31ZY81twUzAfN7angAAAIBfva8sTSDUGKsWWIXkdbVdvM4X14K4gFdy0ZJVzaVOtZ6alysW6UQypnsl6jfnbKvsZ0tFgvcX/CPyqNY/gMR9lyh/TCZ4XQcbqeqYPuceGehz+jL5vArfqsW2fJYFzgCcklmr/VxtP5h6J/T0c9YcDgc/xIfWdZAlznOnphI/FA==')}.should_not raise_error
+      it "supports a valid key like a 1024 bit dsa key" do
+        expect { described_class.new(:name => "whev", :type => :dsa, :user => "nobody", :key => 'AAAAB3NzaC1kc3MAAACBAI80iR78QCgpO4WabVqHHdEDigOjUEHwIjYHIubR/7u7DYrXY+e+TUmZ0CVGkiwB/0yLHK5dix3Y/bpj8ZiWCIhFeunnXccOdE4rq5sT2V3l1p6WP33RpyVYbLmeuHHl5VQ1CecMlca24nHhKpfh6TO/FIwkMjghHBfJIhXK+0w/AAAAFQDYzLupuMY5uz+GVrcP+Kgd8YqMmwAAAIB3SVN71whLWjFPNTqGyyIlMy50624UfNOaH4REwO+Of3wm/cE6eP8n75vzTwQGBpJX3BPaBGW1S1Zp/DpTOxhCSAwZzAwyf4WgW7YyAOdxN3EwTDJZeyiyjWMAOjW9/AOWt9gtKg0kqaylbMHD4kfiIhBzo31ZY81twUzAfN7angAAAIBfva8sTSDUGKsWWIXkdbVdvM4X14K4gFdy0ZJVzaVOtZ6alysW6UQypnsl6jfnbKvsZ0tFgvcX/CPyqNY/gMR9lyh/TCZ4XQcbqeqYPuceGehz+jL5vArfqsW2fJYFzgCcklmr/VxtP5h6J/T0c9YcDgc/xIfWdZAlznOnphI/FA==')}.to_not raise_error
       end
 
-      it "should not support whitespaces" do
-        proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody", :key => 'AAA FA==')}.should raise_error(Puppet::Error,/Key must not contain whitespace/)
+      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 "should support flags as options" do
-        proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'cert-authority')}.should_not raise_error
-        proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'no-port-forwarding')}.should_not raise_error
+      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
       end
 
-      it "should support key-value pairs as options" do
-        proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'command="command"')}.should_not raise_error
+      it "supports key-value pairs as options" do
+        expect { described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'command="command"')}.to_not raise_error
       end
 
-      it "should support key-value pairs where value consist of multiple items" do
-        proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'from="*.domain1,host1.domain2"')}.should_not raise_error
+      it "supports key-value pairs where value consist of multiple items" do
+        expect { described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'from="*.domain1,host1.domain2"')}.to_not raise_error
       end
 
-      it "should support environments as options" do
-        proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'environment="NAME=value"')}.should_not raise_error
+      it "supports environments as options" do
+        expect { described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'environment="NAME=value"')}.to_not raise_error
       end
 
-      it "should support multiple options as an array" do
-        proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => ['cert-authority','environment="NAME=value"'])}.should_not raise_error
+      it "supports multiple options as an array" do
+        expect { described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => ['cert-authority','environment="NAME=value"'])}.to_not raise_error
       end
 
-      it "should not support a comma separated list" do
-        proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'cert-authority,no-port-forwarding')}.should raise_error(Puppet::Error, /must be provided as an array/)
+      it "doesn't support a comma separated list" do
+        expect { described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'cert-authority,no-port-forwarding')}.to raise_error(Puppet::Error, /must be provided as an array/)
       end
 
-      it "should use :absent as a default value" do
-        @class.new(:name => "whev", :type => :rsa, :user => "nobody").should(:options).should == [:absent]
+      it "uses :absent as a default value" do
+        expect(described_class.new(:name => "whev", :type => :rsa, :user => "nobody").should(:options)).to eq [:absent]
       end
 
       it "property should return well formed string of arrays from is_to_s" do
-        resource = @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => ["a","b","c"])
-        resource.property(:options).is_to_s(["a","b","c"]).should == "a,b,c"
+        resource = described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => ["a","b","c"])
+        expect(resource.property(:options).is_to_s(["a","b","c"])).to eq "a,b,c"
       end
 
       it "property should return well formed string of arrays from should_to_s" do
-        resource = @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => ["a","b","c"])
-        resource.property(:options).should_to_s(["a","b","c"]).should == "a,b,c"
+        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 "should support present users" do
-        proc { @class.new(:name => "whev", :type => :rsa, :user => "root") }.should_not raise_error
+      it "supports present users" do
+        described_class.new(:name => "whev", :type => :rsa, :user => "root")
       end
 
-      it "should support absent users" do
-        proc { @class.new(:name => "whev", :type => :rsa, :user => "ihopeimabsent") }.should_not raise_error
+      it "supports absent users" do
+        described_class.new(:name => "whev", :type => :rsa, :user => "ihopeimabsent")
       end
 
     end
 
     describe "for target" do
 
-      it "should support absolute paths" do
-        proc { @class.new(:name => "whev", :type => :rsa, :target => "/tmp/here") }.should_not raise_error
+      it "supports absolute paths" do
+        described_class.new(:name => "whev", :type => :rsa, :target => "/tmp/here")
       end
 
-      it "should use the user's path if not explicitly specified" do
-        @class.new(:name => "whev", :user => 'root').should(:target).should == File.expand_path("~root/.ssh/authorized_keys")
+      it "uses the user's path if not explicitly specified" do
+        expect(described_class.new(:name => "whev", :user => 'root').should(:target)).to eq File.expand_path("~root/.ssh/authorized_keys")
       end
 
-      it "should not consider the user's path if explicitly specified" do
-        @class.new(:name => "whev", :user => 'root', :target => '/tmp/here').should(:target).should == '/tmp/here'
+      it "doesn't consider the user's path if explicitly specified" do
+        expect(described_class.new(:name => "whev", :user => 'root', :target => '/tmp/here').should(:target)).to eq '/tmp/here'
       end
 
-      it "should inform about an absent user" do
+      it "informs about an absent user" do
         Puppet::Log.level = :debug
-        @class.new(:name => "whev", :user => 'idontexist').should(:target)
+        described_class.new(:name => "whev", :user => 'idontexist').should(:target)
         @logs.map(&:message).should include("The required user is not yet present on the system")
       end
 
@@ -194,27 +197,27 @@ describe ssh_authorized_key, :unless => Puppet.features.microsoft_windows? do
 
   describe "when neither user nor target is specified" do
 
-    it "should raise an error" do
-      proc do
-        @class.new(
+    it "raises an error" do
+      expect do
+        described_class.new(
           :name   => "Test",
           :key    => "AAA",
           :type   => "ssh-rsa",
           :ensure => :present)
-      end.should raise_error(Puppet::Error,/user.*or.*target.*mandatory/)
+      end.to raise_error(Puppet::Error,/user.*or.*target.*mandatory/)
     end
 
   end
 
   describe "when both target and user are specified" do
 
-    it "should use target" do
-      resource = @class.new(
+    it "uses target" do
+      resource = described_class.new(
         :name => "Test",
         :user => "root",
         :target => "/tmp/blah"
       )
-      resource.should(:target).should == "/tmp/blah"
+      expect(resource.should(:target)).to eq "/tmp/blah"
     end
 
   end
@@ -222,32 +225,32 @@ describe ssh_authorized_key, :unless => Puppet.features.microsoft_windows? do
 
   describe "when user is specified" do
 
-    it "should determine target" do
-      resource = @class.new(
+    it "determines target" do
+      resource = described_class.new(
         :name   => "Test",
         :user   => "root"
       )
       target = File.expand_path("~root/.ssh/authorized_keys")
-      resource.should(:target).should == target
+      expect(resource.should(:target)).to eq target
     end
 
     # Bug #2124 - ssh_authorized_key always changes target if target is not defined
-    it "should not raise spurious change events" do
-      resource = @class.new(:name => "Test", :user => "root")
+    it "doesn't raise spurious change events" do
+      resource = described_class.new(:name => "Test", :user => "root")
       target = File.expand_path("~root/.ssh/authorized_keys")
-      resource.property(:target).safe_insync?(target).should == true
+      expect(resource.property(:target).safe_insync?(target)).to eq true
     end
 
   end
 
   describe "when calling validate" do
 
-    it "should not crash on a non-existant user" do
-      resource = @class.new(
+    it "doesn't crash on a non-existant user" do
+      resource = described_class.new(
         :name   => "Test",
         :user   => "ihopesuchuserdoesnotexist"
       )
-      proc { resource.validate }.should_not raise_error
+      resource.validate
     end
 
   end