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

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Puppet::Type.type(:exec).provider(:windows), :as_platform => :windows do
+describe Puppet::Type.type(:exec).provider(:windows), :if => Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
 
   let(:resource) { Puppet::Type.type(:exec).new(:title => 'C:\foo', :provider => :windows) }
@@ -17,29 +17,29 @@ describe Puppet::Type.type(:exec).provider(:windows), :as_platform => :windows d
   describe "#extractexe" do
     describe "when the command has no arguments" do
       it "should return the command if it's quoted" do
-        provider.extractexe('"foo"').should == 'foo'
+        expect(provider.extractexe('"foo"')).to eq('foo')
       end
 
       it "should return the command if it's quoted and contains spaces" do
-        provider.extractexe('"foo bar"').should == 'foo bar'
+        expect(provider.extractexe('"foo bar"')).to eq('foo bar')
       end
 
       it "should return the command if it's not quoted" do
-        provider.extractexe('foo').should == 'foo'
+        expect(provider.extractexe('foo')).to eq('foo')
       end
     end
 
     describe "when the command has arguments" do
       it "should return the command if it's quoted" do
-        provider.extractexe('"foo" bar baz').should == 'foo'
+        expect(provider.extractexe('"foo" bar baz')).to eq('foo')
       end
 
       it "should return the command if it's quoted and contains spaces" do
-        provider.extractexe('"foo bar" baz "quux quiz"').should == 'foo bar'
+        expect(provider.extractexe('"foo bar" baz "quux quiz"')).to eq('foo bar')
       end
 
       it "should return the command if it's not quoted" do
-        provider.extractexe('foo bar baz').should == 'foo'
+        expect(provider.extractexe('foo bar baz')).to eq('foo')
       end
     end
   end
@@ -50,7 +50,7 @@ describe Puppet::Type.type(:exec).provider(:windows), :as_platform => :windows d
         command = tmpfile('command')
         FileUtils.touch(command)
 
-        provider.checkexe(command).should == nil
+        expect(provider.checkexe(command)).to eq(nil)
       end
       it "should fail if the command doesn't exist" do
         command = tmpfile('command')
@@ -95,13 +95,13 @@ describe Puppet::Type.type(:exec).provider(:windows), :as_platform => :windows d
     end
 
     it "should not fail if the command is absolute and there is no path" do
-      provider.validatecmd('C:\foo').should == nil
+      expect(provider.validatecmd('C:\foo')).to eq(nil)
     end
 
     it "should not fail if the command is not absolute and there is a path" do
       resource[:path] = 'C:\path;C:\another_path'
 
-      provider.validatecmd('foo').should == nil
+      expect(provider.validatecmd('foo')).to eq(nil)
     end
   end
 end

data/spec/unit/provider/exec_spec.rb

@@ -5,7 +5,7 @@ require 'puppet/provider/exec'
 describe Puppet::Provider::Exec do
   describe "#extractexe" do
     it "should return the first element of an array" do
-      subject.extractexe(['one', 'two']).should == 'one'
+      expect(subject.extractexe(['one', 'two'])).to eq('one')
     end
 
     {
@@ -27,7 +27,7 @@ describe Puppet::Provider::Exec do
       ['', ' and args', ' "and args"', " 'and args'"].each do |args|
         command = base_command + args
         it "should extract #{exe.inspect} from #{command.inspect}" do
-          subject.extractexe(command).should == exe
+          expect(subject.extractexe(command)).to eq(exe)
         end
       end
     end

data/spec/unit/provider/file/posix_spec.rb

@@ -6,7 +6,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
   include PuppetSpec::Files
 
   let(:path) { tmpfile('posix_file_spec') }
-  let(:resource) { Puppet::Type.type(:file).new :path => path, :mode => 0777, :provider => described_class.name }
+  let(:resource) { Puppet::Type.type(:file).new :path => path, :mode => '0777', :provider => described_class.name }
   let(:provider) { resource.provider }
 
   describe "#mode" do
@@ -14,11 +14,11 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
       FileUtils.touch(path)
       File.chmod(0644, path)
 
-      provider.mode.should == '644'
+      expect(provider.mode).to eq('0644')
     end
 
     it "should return absent if the file doesn't exist" do
-      provider.mode.should == :absent
+      expect(provider.mode).to eq(:absent)
     end
   end
 
@@ -29,12 +29,12 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
 
       provider.mode = '0755'
 
-      provider.mode.should == '755'
+      expect(provider.mode).to eq('0755')
     end
 
     it "should pass along any errors encountered" do
       expect do
-        provider.mode = '644'
+        provider.mode = '0644'
       end.to raise_error(Puppet::Error, /failed to set mode/)
     end
   end
@@ -43,21 +43,21 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     it "should return the name of the user identified by the id" do
       Etc.stubs(:getpwuid).with(501).returns(Struct::Passwd.new('jilluser', nil, 501))
 
-      provider.uid2name(501).should == 'jilluser'
+      expect(provider.uid2name(501)).to eq('jilluser')
     end
 
     it "should return the argument if it's already a name" do
-      provider.uid2name('jilluser').should == 'jilluser'
+      expect(provider.uid2name('jilluser')).to eq('jilluser')
     end
 
     it "should return nil if the argument is above the maximum uid" do
-      provider.uid2name(Puppet[:maximum_uid] + 1).should == nil
+      expect(provider.uid2name(Puppet[:maximum_uid] + 1)).to eq(nil)
     end
 
     it "should return nil if the user doesn't exist" do
       Etc.expects(:getpwuid).raises(ArgumentError, "can't find user for 999")
 
-      provider.uid2name(999).should == nil
+      expect(provider.uid2name(999)).to eq(nil)
     end
   end
 
@@ -68,17 +68,17 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
       Etc.stubs(:getpwnam).with('bobbo').returns(passwd)
       Etc.stubs(:getpwuid).with(502).returns(passwd)
 
-      provider.name2uid('bobbo').should == 502
+      expect(provider.name2uid('bobbo')).to eq(502)
     end
 
     it "should return the argument if it's already an id" do
-      provider.name2uid('503').should == 503
+      expect(provider.name2uid('503')).to eq(503)
     end
 
     it "should return false if the user doesn't exist" do
       Etc.stubs(:getpwnam).with('chuck').raises(ArgumentError, "can't find user for chuck")
 
-      provider.name2uid('chuck').should == false
+      expect(provider.name2uid('chuck')).to eq(false)
     end
   end
 
@@ -87,19 +87,19 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
       FileUtils.touch(path)
       owner = Puppet::FileSystem.stat(path).uid
 
-      provider.owner.should == owner
+      expect(provider.owner).to eq(owner)
     end
 
     it "should return absent if the file can't be statted" do
-      provider.owner.should == :absent
+      expect(provider.owner).to eq(:absent)
     end
 
     it "should warn and return :silly if the value is beyond the maximum uid" do
       stat = stub('stat', :uid => Puppet[:maximum_uid] + 1)
       resource.stubs(:stat).returns(stat)
 
-      provider.owner.should == :silly
-      @logs.should be_any {|log| log.level == :warning and log.message =~ /Apparently using negative UID/}
+      expect(provider.owner).to eq(:silly)
+      expect(@logs).to be_any {|log| log.level == :warning and log.message =~ /Apparently using negative UID/}
     end
   end
 
@@ -135,21 +135,21 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     it "should return the name of the group identified by the id" do
       Etc.stubs(:getgrgid).with(501).returns(Struct::Passwd.new('unicorns', nil, nil, 501))
 
-      provider.gid2name(501).should == 'unicorns'
+      expect(provider.gid2name(501)).to eq('unicorns')
     end
 
     it "should return the argument if it's already a name" do
-      provider.gid2name('leprechauns').should == 'leprechauns'
+      expect(provider.gid2name('leprechauns')).to eq('leprechauns')
     end
 
     it "should return nil if the argument is above the maximum gid" do
-      provider.gid2name(Puppet[:maximum_uid] + 1).should == nil
+      expect(provider.gid2name(Puppet[:maximum_uid] + 1)).to eq(nil)
     end
 
     it "should return nil if the group doesn't exist" do
       Etc.expects(:getgrgid).raises(ArgumentError, "can't find group for 999")
 
-      provider.gid2name(999).should == nil
+      expect(provider.gid2name(999)).to eq(nil)
     end
   end
 
@@ -160,17 +160,17 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
       Etc.stubs(:getgrnam).with('penguins').returns(passwd)
       Etc.stubs(:getgrgid).with(502).returns(passwd)
 
-      provider.name2gid('penguins').should == 502
+      expect(provider.name2gid('penguins')).to eq(502)
     end
 
     it "should return the argument if it's already an id" do
-      provider.name2gid('503').should == 503
+      expect(provider.name2gid('503')).to eq(503)
     end
 
     it "should return false if the group doesn't exist" do
       Etc.stubs(:getgrnam).with('wombats').raises(ArgumentError, "can't find group for wombats")
 
-      provider.name2gid('wombats').should == false
+      expect(provider.name2gid('wombats')).to eq(false)
     end
 
   end
@@ -180,19 +180,19 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
       FileUtils.touch(path)
       group = Puppet::FileSystem.stat(path).gid
 
-      provider.group.should == group
+      expect(provider.group).to eq(group)
     end
 
     it "should return absent if the file can't be statted" do
-      provider.group.should == :absent
+      expect(provider.group).to eq(:absent)
     end
 
     it "should warn and return :silly if the value is beyond the maximum gid" do
       stat = stub('stat', :gid => Puppet[:maximum_uid] + 1)
       resource.stubs(:stat).returns(stat)
 
-      provider.group.should == :silly
-      @logs.should be_any {|log| log.level == :warning and log.message =~ /Apparently using negative GID/}
+      expect(provider.group).to eq(:silly)
+      expect(@logs).to be_any {|log| log.level == :warning and log.message =~ /Apparently using negative GID/}
     end
   end
 

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

@@ -12,21 +12,21 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
   include PuppetSpec::Files
 
   let(:path) { tmpfile('windows_file_spec') }
-  let(:resource) { Puppet::Type.type(:file).new :path => path, :mode => 0777, :provider => described_class.name }
+  let(:resource) { Puppet::Type.type(:file).new :path => path, :mode => '0777', :provider => described_class.name }
   let(:provider) { resource.provider }
   let(:sid)      { 'S-1-1-50' }
   let(:account)  { 'quinn' }
 
   describe "#mode" do
-    it "should return a string with the higher-order bits stripped away" do
+    it "should return a string representing the mode in 4-digit octal notation" do
       FileUtils.touch(path)
       WindowsSecurity.set_mode(0644, path)
 
-      provider.mode.should == '644'
+      expect(provider.mode).to eq('0644')
     end
 
     it "should return absent if the file doesn't exist" do
-      provider.mode.should == :absent
+      expect(provider.mode).to eq(:absent)
     end
   end
 
@@ -37,12 +37,12 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
 
       provider.mode = '0755'
 
-      provider.mode.should == '755'
+      expect(provider.mode).to eq('0755')
     end
 
     it "should pass along any errors encountered" do
       expect do
-        provider.mode = '644'
+        provider.mode = '0644'
       end.to raise_error(Puppet::Error, /failed to set mode/)
     end
   end
@@ -52,21 +52,21 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
       Puppet::Util::Windows::SID.expects(:valid_sid?).with(sid).returns(true)
       Puppet::Util::Windows::SID.expects(:sid_to_name).with(sid).returns(account)
 
-      provider.id2name(sid).should == account
+      expect(provider.id2name(sid)).to eq(account)
     end
 
     it "should return the argument if it's already a name" do
       Puppet::Util::Windows::SID.expects(:valid_sid?).with(account).returns(false)
       Puppet::Util::Windows::SID.expects(:sid_to_name).never
 
-      provider.id2name(account).should == account
+      expect(provider.id2name(account)).to eq(account)
     end
 
     it "should return nil if the user doesn't exist" do
       Puppet::Util::Windows::SID.expects(:valid_sid?).with(sid).returns(true)
       Puppet::Util::Windows::SID.expects(:sid_to_name).with(sid).returns(nil)
 
-      provider.id2name(sid).should == nil
+      expect(provider.id2name(sid)).to eq(nil)
     end
   end
 
@@ -74,7 +74,7 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
     it "should delegate to name_to_sid" do
       Puppet::Util::Windows::SID.expects(:name_to_sid).with(account).returns(sid)
 
-      provider.name2id(account).should == sid
+      expect(provider.name2id(account)).to eq(sid)
     end
   end
 
@@ -83,11 +83,11 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
       FileUtils.touch(resource[:path])
       provider.stubs(:get_owner).with(resource[:path]).returns(sid)
 
-      provider.owner.should == sid
+      expect(provider.owner).to eq(sid)
     end
 
     it "should return absent if the file doesn't exist" do
-      provider.owner.should == :absent
+      expect(provider.owner).to eq(:absent)
     end
   end
 
@@ -111,11 +111,11 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
       FileUtils.touch(resource[:path])
       provider.stubs(:get_group).with(resource[:path]).returns(sid)
 
-      provider.group.should == sid
+      expect(provider.group).to eq(sid)
     end
 
     it "should return absent if the file doesn't exist" do
-      provider.group.should == :absent
+      expect(provider.group).to eq(:absent)
     end
   end
 
@@ -135,7 +135,7 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
   end
 
   describe "when validating" do
-    {:owner => 'foo', :group => 'foo', :mode => 0777}.each do |k,v|
+    {:owner => 'foo', :group => 'foo', :mode => '0777'}.each do |k,v|
       it "should fail if the filesystem doesn't support ACLs and we're managing #{k}" do
         described_class.any_instance.stubs(:supports_acl?).returns false
 

data/spec/unit/provider/group/groupadd_spec.rb

@@ -59,7 +59,7 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
       it "should raise an exception for duplicate GID if allowdupe is not set and duplicate GIDs exist" do
         resource[:gid] = 505
         provider.stubs(:findgroup).returns(true)
-        lambda { provider.create }.should raise_error(Puppet::Error, "GID 505 already exists, use allowdupe to force group creation")
+        expect { provider.create }.to raise_error(Puppet::Error, "GID 505 already exists, use allowdupe to force group creation")
      end
     end
 

data/spec/unit/provider/group/ldap_spec.rb

@@ -5,31 +5,31 @@ provider_class = Puppet::Type.type(:group).provider(:ldap)
 
 describe provider_class do
   it "should have the Ldap provider class as its baseclass" do
-    provider_class.superclass.should equal(Puppet::Provider::Ldap)
+    expect(provider_class.superclass).to equal(Puppet::Provider::Ldap)
   end
 
   it "should manage :posixGroup objectclass" do
-    provider_class.manager.objectclasses.should == [:posixGroup]
+    expect(provider_class.manager.objectclasses).to eq([:posixGroup])
   end
 
   it "should use 'ou=Groups' as its relative base" do
-    provider_class.manager.location.should == "ou=Groups"
+    expect(provider_class.manager.location).to eq("ou=Groups")
   end
 
   it "should use :cn as its rdn" do
-    provider_class.manager.rdn.should == :cn
+    expect(provider_class.manager.rdn).to eq(:cn)
   end
 
   it "should map :name to 'cn'" do
-    provider_class.manager.ldap_name(:name).should == 'cn'
+    expect(provider_class.manager.ldap_name(:name)).to eq('cn')
   end
 
   it "should map :gid to 'gidNumber'" do
-    provider_class.manager.ldap_name(:gid).should == 'gidNumber'
+    expect(provider_class.manager.ldap_name(:gid)).to eq('gidNumber')
   end
 
   it "should map :members to 'memberUid', to be used by the user ldap provider" do
-    provider_class.manager.ldap_name(:members).should == 'memberUid'
+    expect(provider_class.manager.ldap_name(:members)).to eq('memberUid')
   end
 
   describe "when being created" do
@@ -75,7 +75,7 @@ describe provider_class do
   end
 
   it "should have a method for converting group names to GIDs" do
-    provider_class.should respond_to(:name2id)
+    expect(provider_class).to respond_to(:name2id)
   end
 
   describe "when converting from a group name to GID" do
@@ -86,16 +86,16 @@ describe provider_class do
 
     it "should return nil if no group is found" do
       provider_class.manager.expects(:search).with("cn=foo").returns nil
-      provider_class.name2id("foo").should be_nil
+      expect(provider_class.name2id("foo")).to be_nil
       provider_class.manager.expects(:search).with("cn=bar").returns []
-      provider_class.name2id("bar").should be_nil
+      expect(provider_class.name2id("bar")).to be_nil
     end
 
     # We shouldn't ever actually have more than one gid, but it doesn't hurt
     # to test for the possibility.
     it "should return the first gid from the first returned group" do
       provider_class.manager.expects(:search).with("cn=foo").returns [{:name => "foo", :gid => [10, 11]}, {:name => :bar, :gid => [20, 21]}]
-      provider_class.name2id("foo").should == 10
+      expect(provider_class.name2id("foo")).to eq(10)
     end
   end
 end

data/spec/unit/provider/group/pw_spec.rb

@@ -20,7 +20,7 @@ describe provider_class do
     end
 
     it "should run pw with no additional flags when no properties are given" do
-      provider.addcmd.must == [provider_class.command(:pw), "groupadd", "testgroup"]
+      expect(provider.addcmd).to eq([provider_class.command(:pw), "groupadd", "testgroup"])
       provider.expects(:execute).with([provider_class.command(:pw), "groupadd", "testgroup"], kind_of(Hash))
       provider.create
     end
@@ -53,7 +53,7 @@ describe provider_class do
   describe "when deleting groups" do
     it "should run pw with no additional flags" do
       provider.expects(:exists?).returns true
-      provider.deletecmd.must == [provider_class.command(:pw), "groupdel", "testgroup"]
+      expect(provider.deletecmd).to eq([provider_class.command(:pw), "groupdel", "testgroup"])
       provider.expects(:execute).with([provider_class.command(:pw), "groupdel", "testgroup"])
       provider.delete
     end
@@ -61,7 +61,7 @@ describe provider_class do
 
   describe "when modifying groups" do
     it "should run pw with the correct arguments" do
-      provider.modifycmd("gid", 12345).must == [provider_class.command(:pw), "groupmod", "testgroup", "-g", 12345]
+      expect(provider.modifycmd("gid", 12345)).to eq([provider_class.command(:pw), "groupmod", "testgroup", "-g", 12345])
       provider.expects(:execute).with([provider_class.command(:pw), "groupmod", "testgroup", "-g", 12345])
       provider.gid = 12345
     end