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

data/spec/unit/provider/user/windows_adsi_spec.rb

@@ -26,25 +26,25 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
       stub_users = names.map{|n| stub(:name => n)}
       connection.stubs(:execquery).with('select name from win32_useraccount where localaccount = "TRUE"').returns(stub_users)
 
-      described_class.instances.map(&:name).should =~ names
+      expect(described_class.instances.map(&:name)).to match(names)
     end
   end
 
   it "should provide access to a Puppet::Util::Windows::ADSI::User object" do
-    provider.user.should be_a(Puppet::Util::Windows::ADSI::User)
+    expect(provider.user).to be_a(Puppet::Util::Windows::ADSI::User)
   end
 
   describe "when managing groups" do
     it 'should return the list of groups as a comma-separated list' do
       provider.user.stubs(:groups).returns ['group1', 'group2', 'group3']
 
-      provider.groups.should == 'group1,group2,group3'
+      expect(provider.groups).to eq('group1,group2,group3')
     end
 
     it "should return absent if there are no groups" do
       provider.user.stubs(:groups).returns []
 
-      provider.groups.should == ''
+      expect(provider.groups).to eq('')
     end
 
     it 'should be able to add a user to a set of groups' do
@@ -103,7 +103,7 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
       resource[:password] = 'plaintext'
       provider.user.expects(:password_is?).with('plaintext').returns true
 
-      provider.password.should == 'plaintext'
+      expect(provider.password).to eq('plaintext')
 
     end
 
@@ -111,7 +111,7 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
       resource[:password] = 'plaintext'
       provider.user.expects(:password_is?).with('plaintext').returns false
 
-      provider.password.should == :absent
+      expect(provider.password).to be_nil
     end
 
     it 'should not create a user if a group by the same name exists' do
@@ -119,29 +119,15 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
       expect{ provider.create }.to raise_error( Puppet::Error,
         /Cannot create user if group 'testuser' exists./ )
     end
-
-    it "should fail with an actionable message when trying to create an active directory user" do
-      resource[:name] = 'DOMAIN\testdomainuser'
-      Puppet::Util::Windows::ADSI::Group.expects(:exists?).with(resource[:name]).returns(false)
-      connection.expects(:Create)
-      connection.expects(:Get).with('UserFlags')
-      connection.expects(:Put).with('UserFlags', true)
-      connection.expects(:SetInfo).raises( WIN32OLERuntimeError.new("(in OLE method `SetInfo': )\n    OLE error code:8007089A in Active Directory\n      The specified username is invalid.\r\n\n    HRESULT error code:0x80020009\n      Exception occurred."))
-
-      expect{ provider.create }.to raise_error(
-        Puppet::Error,
-        /not able to create\/delete domain users/
-      )
-    end
   end
 
   it 'should be able to test whether a user exists' do
     Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
     Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection')
-    provider.should be_exists
+    expect(provider).to be_exists
 
     Puppet::Util::Windows::ADSI.stubs(:connect).returns nil
-    provider.should_not be_exists
+    expect(provider).not_to be_exists
   end
 
   it 'should be able to delete a user' do
@@ -150,14 +136,6 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
     provider.delete
   end
 
-  it 'should not run commit on a deleted user' do
-    connection.expects(:Delete).with('user', 'testuser')
-    connection.expects(:SetInfo).never
-
-    provider.delete
-    provider.flush
-  end
-
   it 'should delete the profile if managehome is set' do
     resource[:managehome] = true
 
@@ -178,7 +156,7 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
   it "should return the user's SID as uid" do
     Puppet::Util::Windows::SID.expects(:name_to_sid).with('testuser').returns('S-1-5-21-1362942247-2130103807-3279964888-1111')
 
-    provider.uid.should == 'S-1-5-21-1362942247-2130103807-3279964888-1111'
+    expect(provider.uid).to eq('S-1-5-21-1362942247-2130103807-3279964888-1111')
   end
 
   it "should fail when trying to manage the uid property" do

data/spec/unit/provider/vlan/cisco_spec.rb

@@ -13,11 +13,11 @@ describe provider_class do
   end
 
   it "should have a parent of Puppet::Provider::Cisco" do
-    provider_class.should < Puppet::Provider::Cisco
+    expect(provider_class).to be < Puppet::Provider::Cisco
   end
 
   it "should have an instances method" do
-    provider_class.should respond_to(:instances)
+    expect(provider_class).to respond_to(:instances)
   end
 
   describe "when looking up instances at prefetch" do
@@ -32,7 +32,7 @@ describe provider_class do
 
     it "should return only the given vlan" do
       @device.expects(:parse_vlans).returns({"200" => { :description => "thisone" }, "1" => { :description => "nothisone" }})
-      provider_class.lookup(@device, "200").should == {:description => "thisone" }
+      expect(provider_class.lookup(@device, "200")).to eq({:description => "thisone" })
     end
 
   end

data/spec/unit/provider/yumrepo/inifile_spec.rb

@@ -239,21 +239,21 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile) do
 
     it "returns the default directories if yum.conf doesn't contain a `reposdir` entry" do
       described_class.stubs(:find_conf_value).with('reposdir', '/etc/yum.conf')
-      described_class.reposdir('/etc/yum.conf').should == defaults
+      expect(described_class.reposdir('/etc/yum.conf')).to eq(defaults)
     end
 
     it "includes the directory specified by the yum.conf 'reposdir' entry when the directory is present" do
       Puppet::FileSystem.expects(:exist?).with("/etc/yum/extra.repos.d").returns(true)
 
       described_class.expects(:find_conf_value).with('reposdir', '/etc/yum.conf').returns "/etc/yum/extra.repos.d"
-      described_class.reposdir('/etc/yum.conf').should include("/etc/yum/extra.repos.d")
+      expect(described_class.reposdir('/etc/yum.conf')).to include("/etc/yum/extra.repos.d")
     end
 
     it "doesn't include the directory specified by the yum.conf 'reposdir' entry when the directory is absent" do
       Puppet::FileSystem.expects(:exist?).with("/etc/yum/extra.repos.d").returns(false)
 
       described_class.expects(:find_conf_value).with('reposdir', '/etc/yum.conf').returns "/etc/yum/extra.repos.d"
-      described_class.reposdir('/etc/yum.conf').should_not include("/etc/yum/extra.repos.d")
+      expect(described_class.reposdir('/etc/yum.conf')).not_to include("/etc/yum/extra.repos.d")
     end
 
     it "logs a warning and returns an empty array if none of the specified repo directories exist" do

data/spec/unit/provider/zfs/zfs_spec.rb

@@ -17,15 +17,15 @@ describe Puppet::Type.type(:zfs).provider(:zfs) do
 
   context ".instances" do
     it "should have an instances method" do
-      provider.class.should respond_to(:instances)
+      expect(provider.class).to respond_to(:instances)
     end
 
     it "should list instances" do
       provider.class.expects(:zfs).with(:list,'-H').returns File.read(my_fixture('zfs-list.out'))
       instances = provider.class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
-      instances.size.should == 2
-      instances[0].should == {:name => 'rpool', :ensure => :present}
-      instances[1].should == {:name => 'rpool/ROOT', :ensure => :present}
+      expect(instances.size).to eq(2)
+      expect(instances[0]).to eq({:name => 'rpool', :ensure => :present})
+      expect(instances[1]).to eq({:name => 'rpool/ROOT', :ensure => :present})
     end
   end
 
@@ -33,11 +33,11 @@ describe Puppet::Type.type(:zfs).provider(:zfs) do
     it 'should return an array of properties' do
       resource[:mountpoint] = '/foo'
 
-      provider.add_properties.should == ['-o', "mountpoint=/foo"]
+      expect(provider.add_properties).to eq(['-o', "mountpoint=/foo"])
     end
 
     it 'should return an empty array' do
-      provider.add_properties.should == []
+      expect(provider.add_properties).to eq([])
     end
   end
 
@@ -71,15 +71,15 @@ describe Puppet::Type.type(:zfs).provider(:zfs) do
   context "#exists?" do
     it "should return true if the resource exists" do
       #return stuff because we have to slice and dice it
-      provider.expects(:zfs).with(:list).returns("NAME USED AVAIL REFER MOUNTPOINT\nmyzfs 100K 27.4M /myzfs")
+      provider.expects(:zfs).with(:list, name)
 
-      provider.should be_exists
+      expect(provider).to be_exists
     end
 
     it "should return false if returned values don't match the name" do
-      provider.expects(:zfs).with(:list).returns("no soup for you")
+      provider.expects(:zfs).with(:list, name).raises(Puppet::ExecutionFailure, "Failed")
 
-      provider.should_not be_exists
+      expect(provider).not_to be_exists
     end
   end
 
@@ -93,7 +93,7 @@ describe Puppet::Type.type(:zfs).provider(:zfs) do
       it "should get #{prop}" do
         provider.expects(:zfs).with(:get, '-H', '-o', 'value', prop, name).returns("value\n")
 
-        provider.send(prop).should == 'value'
+        expect(provider.send(prop)).to eq('value')
       end
 
       it "should set #{prop}=value" do

data/spec/unit/provider/zone/solaris_spec.rb

@@ -60,11 +60,11 @@ describe Puppet::Type.type(:zone).provider(:solaris) do
     it "should list the instances correctly" do
       described_class.expects(:adm).with(:list, "-cp").returns("0:dummy:running:/::native:shared")
       instances = described_class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
-      instances.size.should == 1
-      instances[0].should == {
+      expect(instances.size).to eq(1)
+      expect(instances[0]).to eq({
         :name=>"dummy",
         :ensure=>:running,
-      }
+      })
     end
   end
   context "#setconfig" do
@@ -85,8 +85,7 @@ describe Puppet::Type.type(:zone).provider(:solaris) do
     end
   end
   context "#getconfig" do
-    describe "with a shared iptype zone" do
-      zone_info =<<-EOF
+    zone_info =<<-EOF
 zonename: dummy
 zonepath: /dummy/z
 brand: native
@@ -105,49 +104,17 @@ net:
         address: 1.1.1.2
         physical: ex0002
         defrouter not specified
-      EOF
-      it "should correctly parse zone info" do
-        provider.expects(:zonecfg).with(:info).returns(zone_info)
-        provider.getconfig.should == {
-          :brand=>"native",
-          :autoboot=>"true",
-          :"ip-type"=>"shared",
-          :zonename=>"dummy",
-          "net"=>[{:physical=>"ex0001", :address=>"1.1.1.1"}, {:physical=>"ex0002", :address=>"1.1.1.2"}],
-          :zonepath=>"/dummy/z"
-        }
-      end
-    end
-    describe "with an exclusive iptype zone" do
-      zone_info =<<-EOF
-zonename: dummy
-zonepath: /dummy/z
-brand: native
-autoboot: true
-bootargs:
-pool:
-limitpriv:
-scheduling-class:
-ip-type: exclusive
-hostid:
-net:
-        address not specified
-        allowed-address not specified
-        configure-allowed-address: true
-        physical: net1
-        defrouter not specified
-      EOF
-      it "should correctly parse zone info" do
-        provider.expects(:zonecfg).with(:info).returns(zone_info)
-        provider.getconfig.should == {
-          :brand=>"native",
-          :autoboot=>"true",
-          :"ip-type"=>"exclusive",
-          :zonename=>"dummy",
-          "net"=>[{:physical=>"net1",:'configure-allowed-address'=>"true"}],
-          :zonepath=>"/dummy/z"
-        }
-      end
+    EOF
+    it "should correctly parse zone info" do
+      provider.expects(:zonecfg).with(:info).returns(zone_info)
+      expect(provider.getconfig).to eq({
+        :brand=>"native",
+        :autoboot=>"true",
+        :"ip-type"=>"shared",
+        :zonename=>"dummy",
+        "net"=>[{:physical=>"ex0001", :address=>"1.1.1.1"}, {:physical=>"ex0002", :address=>"1.1.1.2"}],
+        :zonepath=>"/dummy/z"
+      })
     end
   end
   context "#flush" do
@@ -187,16 +154,16 @@ net:
   end
   context "#line2hash" do
     it "should parse lines correctly" do
-      described_class.line2hash('0:dummy:running:/z::native:shared').should == {:ensure=>:running, :iptype=>"shared", :path=>"/z", :name=>"dummy", :id=>"0"}
+      expect(described_class.line2hash('0:dummy:running:/z::native:shared')).to eq({:ensure=>:running, :iptype=>"shared", :path=>"/z", :name=>"dummy", :id=>"0"})
     end
     it "should parse lines correctly(2)" do
-      described_class.line2hash('0:dummy:running:/z:ipkg:native:shared').should == {:ensure=>:running, :iptype=>"shared", :path=>"/z", :name=>"dummy", :id=>"0"}
+      expect(described_class.line2hash('0:dummy:running:/z:ipkg:native:shared')).to eq({:ensure=>:running, :iptype=>"shared", :path=>"/z", :name=>"dummy", :id=>"0"})
     end
     it "should parse lines correctly(3)" do
-      described_class.line2hash('-:dummy:running:/z:ipkg:native:shared').should == {:ensure=>:running, :iptype=>"shared", :path=>"/z", :name=>"dummy"}
+      expect(described_class.line2hash('-:dummy:running:/z:ipkg:native:shared')).to eq({:ensure=>:running, :iptype=>"shared", :path=>"/z", :name=>"dummy"})
     end
     it "should parse lines correctly(3)" do
-      described_class.line2hash('-:dummy:running:/z:ipkg:native:exclusive').should == {:ensure=>:running, :iptype=>"exclusive", :path=>"/z", :name=>"dummy"}
+      expect(described_class.line2hash('-:dummy:running:/z:ipkg:native:exclusive')).to eq({:ensure=>:running, :iptype=>"exclusive", :path=>"/z", :name=>"dummy"})
     end
   end
   context "#multi_conf" do
@@ -209,18 +176,18 @@ net:
         when :rm; 'rm:' + str
         end
       end
-      provider.multi_conf(:ip, should, &p).should == "rm:2.2.2.2\nadd:3.3.3.3"
+      expect(provider.multi_conf(:ip, should, &p)).to eq("rm:2.2.2.2\nadd:3.3.3.3")
     end
   end
   context "single props" do
     {:iptype => /set ip-type/, :autoboot => /set autoboot/, :path => /set zonepath/, :pool => /set pool/, :shares => /add rctl/}.each do |p, v|
       it "#{p.to_s}: should correctly return conf string" do
-        provider.send(p.to_s + '_conf', 'dummy').should =~ v
+        expect(provider.send(p.to_s + '_conf', 'dummy')).to match(v)
       end
       it "#{p.to_s}: should correctly set property string" do
         provider.expects((p.to_s + '_conf').intern).returns('dummy')
         provider.expects(:setconfig).with('dummy').returns('dummy2')
-        provider.send(p.to_s + '=', 'dummy').should == 'dummy2'
+        expect(provider.send(p.to_s + '=', 'dummy')).to eq('dummy2')
       end
 
     end

data/spec/unit/provider/zpool/zpool_spec.rb

@@ -27,15 +27,15 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
 
   describe "self.instances" do
     it "should have an instances method" do
-      provider.class.should respond_to(:instances)
+      expect(provider.class).to respond_to(:instances)
     end
 
     it "should list instances" do
       provider.class.expects(:zpool).with(:list,'-H').returns File.read(my_fixture('zpool-list.out'))
       instances = provider.class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
-      instances.size.should == 2
-      instances[0].should == {:name => 'rpool', :ensure => :present}
-      instances[1].should == {:name => 'mypool', :ensure => :present}
+      expect(instances.size).to eq(2)
+      expect(instances[0]).to eq({:name => 'rpool', :ensure => :present})
+      expect(instances[1]).to eq({:name => 'mypool', :ensure => :present})
     end
   end
 
@@ -54,77 +54,77 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
 
     describe "when there is no data" do
       it "should return a hash with ensure=>:absent" do
-        provider.process_zpool_data([])[:ensure].should == :absent
+        expect(provider.process_zpool_data([])[:ensure]).to eq(:absent)
       end
     end
 
     describe "when there is a spare" do
       it "should add the spare disk to the hash" do
         zpool_data.concat ["spares", "spare_disk"]
-        provider.process_zpool_data(zpool_data)[:spare].should == ["spare_disk"]
+        expect(provider.process_zpool_data(zpool_data)[:spare]).to eq(["spare_disk"])
       end
     end
 
     describe "when there are two spares" do
       it "should add the spare disk to the hash as a single string" do
         zpool_data.concat ["spares", "spare_disk", "spare_disk2"]
-        provider.process_zpool_data(zpool_data)[:spare].should == ["spare_disk spare_disk2"]
+        expect(provider.process_zpool_data(zpool_data)[:spare]).to eq(["spare_disk spare_disk2"])
       end
     end
 
     describe "when there is a log" do
       it "should add the log disk to the hash" do
         zpool_data.concat ["logs", "log_disk"]
-        provider.process_zpool_data(zpool_data)[:log].should == ["log_disk"]
+        expect(provider.process_zpool_data(zpool_data)[:log]).to eq(["log_disk"])
       end
     end
 
     describe "when there are two logs" do
       it "should add the log disks to the hash as a single string" do
         zpool_data.concat ["spares", "spare_disk", "spare_disk2"]
-        provider.process_zpool_data(zpool_data)[:spare].should == ["spare_disk spare_disk2"]
+        expect(provider.process_zpool_data(zpool_data)[:spare]).to eq(["spare_disk spare_disk2"])
       end
     end
 
     describe "when the vdev is a single mirror" do
       it "should call create_multi_array with mirror" do
         zpool_data = ["mirrorpool", "mirror", "disk1", "disk2"]
-        provider.process_zpool_data(zpool_data)[:mirror].should == ["disk1 disk2"]
+        expect(provider.process_zpool_data(zpool_data)[:mirror]).to eq(["disk1 disk2"])
       end
     end
 
     describe "when the vdev is a single mirror on solaris 10u9 or later" do
       it "should call create_multi_array with mirror" do
         zpool_data = ["mirrorpool", "mirror-0", "disk1", "disk2"]
-        provider.process_zpool_data(zpool_data)[:mirror].should == ["disk1 disk2"]
+        expect(provider.process_zpool_data(zpool_data)[:mirror]).to eq(["disk1 disk2"])
       end
     end
 
     describe "when the vdev is a double mirror" do
       it "should call create_multi_array with mirror" do
         zpool_data = ["mirrorpool", "mirror", "disk1", "disk2", "mirror", "disk3", "disk4"]
-        provider.process_zpool_data(zpool_data)[:mirror].should == ["disk1 disk2", "disk3 disk4"]
+        expect(provider.process_zpool_data(zpool_data)[:mirror]).to eq(["disk1 disk2", "disk3 disk4"])
       end
     end
 
     describe "when the vdev is a double mirror on solaris 10u9 or later" do
       it "should call create_multi_array with mirror" do
         zpool_data = ["mirrorpool", "mirror-0", "disk1", "disk2", "mirror-1", "disk3", "disk4"]
-        provider.process_zpool_data(zpool_data)[:mirror].should == ["disk1 disk2", "disk3 disk4"]
+        expect(provider.process_zpool_data(zpool_data)[:mirror]).to eq(["disk1 disk2", "disk3 disk4"])
       end
     end
 
     describe "when the vdev is a raidz1" do
       it "should call create_multi_array with raidz1" do
         zpool_data = ["mirrorpool", "raidz1", "disk1", "disk2"]
-        provider.process_zpool_data(zpool_data)[:raidz].should == ["disk1 disk2"]
+        expect(provider.process_zpool_data(zpool_data)[:raidz]).to eq(["disk1 disk2"])
       end
     end
 
     describe "when the vdev is a raidz1 on solaris 10u9 or later" do
       it "should call create_multi_array with raidz1" do
         zpool_data = ["mirrorpool", "raidz1-0", "disk1", "disk2"]
-        provider.process_zpool_data(zpool_data)[:raidz].should == ["disk1 disk2"]
+        expect(provider.process_zpool_data(zpool_data)[:raidz]).to eq(["disk1 disk2"])
       end
     end
 
@@ -132,8 +132,8 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
       it "should call create_multi_array with raidz2 and set the raid_parity" do
         zpool_data = ["mirrorpool", "raidz2", "disk1", "disk2"]
         pool = provider.process_zpool_data(zpool_data)
-        pool[:raidz].should == ["disk1 disk2"]
-        pool[:raid_parity].should == "raidz2"
+        expect(pool[:raidz]).to eq(["disk1 disk2"])
+        expect(pool[:raid_parity]).to eq("raidz2")
       end
     end
 
@@ -141,8 +141,8 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
       it "should call create_multi_array with raidz2 and set the raid_parity" do
         zpool_data = ["mirrorpool", "raidz2-0", "disk1", "disk2"]
         pool = provider.process_zpool_data(zpool_data)
-        pool[:raidz].should == ["disk1 disk2"]
-        pool[:raid_parity].should == "raidz2"
+        expect(pool[:raidz]).to eq(["disk1 disk2"])
+        expect(pool[:raid_parity]).to eq("raidz2")
       end
     end
   end
@@ -155,7 +155,7 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
           pool_hash[field] = 'value'
           provider.stubs(:current_pool).returns(pool_hash)
 
-          provider.send(field).should == 'value'
+          expect(provider.send(field)).to eq('value')
         end
       end
 
@@ -240,12 +240,12 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
 
     it "should return false if the current_pool is absent" do
       provider.expects(:current_pool).returns({:pool => :absent})
-      provider.should_not be_exists
+      expect(provider).not_to be_exists
     end
 
     it "should return true if the current_pool has values" do
       provider.expects(:current_pool).returns({:pool => name})
-      provider.should be_exists
+      expect(provider).to be_exists
     end
   end
 end