puppet 3.8.7 → 4.0.0.rc1

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

@@ -26,7 +26,7 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
       connection.stubs(:execquery).with('select name from win32_group where localaccount = "TRUE"').returns stub_groups
 
-      described_class.instances.map(&:name).should =~ names
+      expect(described_class.instances.map(&:name)).to match(names)
     end
   end
 
@@ -35,76 +35,80 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
     let(:user1) { stub(:account => 'user1', :domain => '.', :to_s => 'user1sid') }
     let(:user2) { stub(:account => 'user2', :domain => '.', :to_s => 'user2sid') }
     let(:user3) { stub(:account => 'user3', :domain => '.', :to_s => 'user3sid') }
-    let(:invalid_user) { SecureRandom.uuid }
 
     before :each do
       Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('user1').returns(user1)
       Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('user2').returns(user2)
       Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('user3').returns(user3)
-      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with(invalid_user).returns(nil)
     end
 
     describe "#members_insync?" do
       it "should return false when current is nil" do
-        provider.members_insync?(nil, ['user2']).should be_false
+        expect(provider.members_insync?(nil, ['user2'])).to be_falsey
       end
 
       it "should return false when should is nil" do
-        provider.members_insync?(['user1'], nil).should be_false
-      end
-
-      it "should return false for differing lists of members" do
-        provider.members_insync?(['user1'], ['user2']).should be_false
-        provider.members_insync?(['user1'], []).should be_false
-        provider.members_insync?([], ['user2']).should be_false
+        expect(provider.members_insync?(['user1'], nil)).to be_falsey
       end
 
       it "should return true for same lists of members" do
-        provider.members_insync?(['user1', 'user2'], ['user1', 'user2']).should be_true
+        expect(provider.members_insync?(['user1', 'user2'], ['user1', 'user2'])).to be_truthy
       end
 
       it "should return true for same lists of unordered members" do
-        provider.members_insync?(['user1', 'user2'], ['user2', 'user1']).should be_true
+        expect(provider.members_insync?(['user1', 'user2'], ['user2', 'user1'])).to be_truthy
       end
 
       it "should return true for same lists of members irrespective of duplicates" do
-        provider.members_insync?(['user1', 'user2', 'user2'], ['user2', 'user1', 'user1']).should be_true
-      end
-
-      it "should return true when current user(s) and should user(s) are empty lists" do
-        provider.members_insync?([], []).should be_true
+        expect(provider.members_insync?(['user1', 'user2', 'user2'], ['user2', 'user1', 'user1'])).to be_truthy
       end
 
       context "when auth_membership => true" do
         before :each do
-          # this is also the default
           resource[:auth_membership] = true
         end
 
-        it "should return false when should user(s) are not the only items in the current" do
-          provider.members_insync?(['user1', 'user2'], ['user1']).should be_false
+        it "should return false when current contains different users than should" do
+          expect(provider.members_insync?(['user1'], ['user2'])).to be_falsey
+        end
+
+        it "should return false when current contains members and should is empty" do
+          expect(provider.members_insync?(['user1'], [])).to be_falsey
         end
 
-        it "should return false when current user(s) is not empty and should is an empty list" do
-          provider.members_insync?(['user1','user2'], []).should be_false
+        it "should return false when current is empty and should contains members" do
+          expect(provider.members_insync?([], ['user2'])).to be_falsey
+        end
+
+        it "should return false when should user(s) are not the only items in the current" do
+          expect(provider.members_insync?(['user1', 'user2'], ['user1'])).to be_falsey
         end
       end
 
       context "when auth_membership => false" do
         before :each do
+          # this is also the default
           resource[:auth_membership] = false
         end
 
-        it "should return true when current user(s) contains at least the should list" do
-          provider.members_insync?(['user1','user2'], ['user1']).should be_true
+        it "should return false when current contains different users than should" do
+          expect(provider.members_insync?(['user1'], ['user2'])).to be_falsey
+        end
+
+        it "should return true when current contains members and should is empty" do
+          expect(provider.members_insync?(['user1'], [])).to be_truthy
         end
 
-        it "should return true when current user(s) is not empty and should is an empty list" do
-          provider.members_insync?(['user1','user2'], []).should be_true
+        it "should return false when current is empty and should contains members" do
+          expect(provider.members_insync?([], ['user2'])).to be_falsey
         end
 
+        it "should return true when current user(s) contains at least the should list" do
+          expect(provider.members_insync?(['user1','user2'], ['user1'])).to be_truthy
+          end
+
         it "should return true when current user(s) contains at least the should list, even unordered" do
-          provider.members_insync?(['user3','user1','user2'], ['user2','user1']).should be_true
+          expect(provider.members_insync?(['user3','user1','user2'], ['user2','user1'])).to be_truthy
         end
       end
     end
@@ -112,30 +116,31 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
     describe "#members_to_s" do
       it "should return an empty string on non-array input" do
         [Object.new, {}, 1, :symbol, ''].each do |input|
-          provider.members_to_s(input).should be_empty
+          expect(provider.members_to_s(input)).to be_empty
         end
       end
       it "should return an empty string on empty or nil users" do
-        provider.members_to_s([]).should be_empty
-        provider.members_to_s(nil).should be_empty
+        expect(provider.members_to_s([])).to be_empty
+        expect(provider.members_to_s(nil)).to be_empty
       end
       it "should return a user string like DOMAIN\\USER" do
-        provider.members_to_s(['user1']).should == '.\user1'
+        expect(provider.members_to_s(['user1'])).to eq('.\user1')
       end
       it "should return a user string like DOMAIN\\USER,DOMAIN2\\USER2" do
-        provider.members_to_s(['user1', 'user2']).should == '.\user1,.\user2'
-      end
-      it "should return the username when it cannot be resolved to a SID (for the sake of resource_harness error messages)" do
-        expect(provider.members_to_s([invalid_user])).to eq("#{invalid_user}")
+        expect(provider.members_to_s(['user1', 'user2'])).to eq('.\user1,.\user2')
       end
     end
   end
 
   describe "when managing members" do
+    before :each do
+      resource[:auth_membership] = true
+    end
+
     it "should be able to provide a list of members" do
       provider.group.stubs(:members).returns ['user1', 'user2', 'user3']
 
-      provider.members.should =~ ['user1', 'user2', 'user3']
+      expect(provider.members).to match_array(['user1', 'user2', 'user3'])
     end
 
     it "should be able to set group members" do
@@ -168,7 +173,8 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
       create = sequence('create')
       group.expects(:commit).in_sequence(create)
-      group.expects(:set_members).with(['user1', 'user2'], true).in_sequence(create)
+      # due to PUP-1967, defaultto false will set the default to nil
+      group.expects(:set_members).with(['user1', 'user2'], nil).in_sequence(create)
 
       provider.create
     end
@@ -179,18 +185,6 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         /Cannot create group if user 'testers' exists./ )
     end
 
-    it "should fail with an actionable message when trying to create an active directory group" do
-      resource[:name] = 'DOMAIN\testdomaingroup'
-      Puppet::Util::Windows::ADSI::User.expects(:exists?).with(resource[:name]).returns(false)
-      connection.expects(:Create)
-      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 groups/
-                                   )
-    end
-
     it 'should commit a newly created group' do
       provider.group.expects( :commit )
 
@@ -201,10 +195,10 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
   it "should be able to test whether a group 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 group" do
@@ -213,17 +207,9 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
     provider.delete
   end
 
-  it 'should not run commit on a deleted group' do
-    connection.expects(:Delete).with('group', 'testers')
-    connection.expects(:SetInfo).never
-
-    provider.delete
-    provider.flush
-  end
-
   it "should report the group's SID as gid" do
     Puppet::Util::Windows::SID.expects(:name_to_sid).with('testers').returns('S-1-5-32-547')
-    provider.gid.should == 'S-1-5-32-547'
+    expect(provider.gid).to eq('S-1-5-32-547')
   end
 
   it "should fail when trying to manage the gid property" do
@@ -232,6 +218,6 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
   end
 
   it "should prefer the domain component from the resolved SID" do
-    provider.members_to_s(['.\Administrators']).should == 'BUILTIN\Administrators'
+    expect(provider.members_to_s(['.\Administrators'])).to eq('BUILTIN\Administrators')
   end
 end

data/spec/unit/provider/host/parsed_spec.rb

@@ -45,26 +45,62 @@ describe provider_class do
     @provider.target_object(@hostfile).read
   end
 
+  describe "when parsing on incomplete line" do
+
+    it "should work for only ip" do
+      expect(@provider.parse_line("127.0.0.1")[:line]).to eq("127.0.0.1")
+    end
+
+    it "should work for only hostname" do
+      expect(@provider.parse_line("www.example.com")[:line]).to eq("www.example.com")
+    end
+
+    it "should work for ip and space" do
+      expect(@provider.parse_line("127.0.0.1 ")[:line]).to eq("127.0.0.1 ")
+    end
+
+    it "should work for hostname and space" do
+      expect(@provider.parse_line("www.example.com ")[:line]).to eq("www.example.com ")
+    end
+
+    it "should work for hostname and host_aliases" do
+      expect(@provider.parse_line("www.example.com  www xyz")[:line]).to eq("www.example.com  www xyz")
+    end
+
+    it "should work for ip and comment" do
+      expect(@provider.parse_line("127.0.0.1  #www xyz")[:line]).to eq("127.0.0.1  #www xyz")
+    end
+
+    it "should work for hostname and comment" do
+      expect(@provider.parse_line("xyz  #www test123")[:line]).to eq("xyz  #www test123")
+    end
+
+    it "should work for crazy incomplete lines" do
+      expect(@provider.parse_line("%th1s is a\t cr$zy    !incompl1t line")[:line]).to eq("%th1s is a\t cr$zy    !incompl1t line")
+    end
+
+  end
+
   describe "when parsing a line with ip and hostname" do
 
     it "should parse an ipv4 from the first field" do
-      @provider.parse_line("127.0.0.1    localhost")[:ip].should == "127.0.0.1"
+      expect(@provider.parse_line("127.0.0.1    localhost")[:ip]).to eq("127.0.0.1")
     end
 
     it "should parse an ipv6 from the first field" do
-      @provider.parse_line("::1     localhost")[:ip].should == "::1"
+      expect(@provider.parse_line("::1     localhost")[:ip]).to eq("::1")
     end
 
     it "should parse the name from the second field" do
-      @provider.parse_line("::1     localhost")[:name].should == "localhost"
+      expect(@provider.parse_line("::1     localhost")[:name]).to eq("localhost")
     end
 
     it "should set an empty comment" do
-      @provider.parse_line("::1     localhost")[:comment].should == ""
+      expect(@provider.parse_line("::1     localhost")[:comment]).to eq("")
     end
 
     it "should set host_aliases to :absent" do
-      @provider.parse_line("::1     localhost")[:host_aliases].should == :absent
+      expect(@provider.parse_line("::1     localhost")[:host_aliases]).to eq(:absent)
     end
 
   end
@@ -75,15 +111,15 @@ describe provider_class do
     end
 
     it "should parse the ip from the first field" do
-      @provider.parse_line(@testline)[:ip].should == "127.0.0.1"
+      expect(@provider.parse_line(@testline)[:ip]).to eq("127.0.0.1")
     end
 
     it "should parse the hostname from the second field" do
-      @provider.parse_line(@testline)[:name].should == "localhost"
+      expect(@provider.parse_line(@testline)[:name]).to eq("localhost")
     end
 
     it "should parse the comment after the first '#' character" do
-      @provider.parse_line(@testline)[:comment].should == 'A comment with a #-char'
+      expect(@provider.parse_line(@testline)[:comment]).to eq('A comment with a #-char')
     end
 
   end
@@ -91,13 +127,13 @@ describe provider_class do
   describe "when parsing a line with ip, hostname and aliases" do
 
     it "should parse alias from the third field" do
-      @provider.parse_line("127.0.0.1   localhost   localhost.localdomain")[:host_aliases].should == "localhost.localdomain"
+      expect(@provider.parse_line("127.0.0.1   localhost   localhost.localdomain")[:host_aliases]).to eq("localhost.localdomain")
     end
 
     it "should parse multiple aliases" do
-      @provider.parse_line("127.0.0.1 host alias1 alias2")[:host_aliases].should == 'alias1 alias2'
-      @provider.parse_line("127.0.0.1 host alias1\talias2")[:host_aliases].should == 'alias1 alias2'
-      @provider.parse_line("127.0.0.1 host alias1\talias2   alias3")[:host_aliases].should == 'alias1 alias2 alias3'
+      expect(@provider.parse_line("127.0.0.1 host alias1 alias2")[:host_aliases]).to eq('alias1 alias2')
+      expect(@provider.parse_line("127.0.0.1 host alias1\talias2")[:host_aliases]).to eq('alias1 alias2')
+      expect(@provider.parse_line("127.0.0.1 host alias1\talias2   alias3")[:host_aliases]).to eq('alias1 alias2 alias3')
     end
 
   end
@@ -110,19 +146,19 @@ describe provider_class do
     end
 
     it "should parse the ip from the first field" do
-      @provider.parse_line(@testline)[:ip].should == "127.0.0.1"
+      expect(@provider.parse_line(@testline)[:ip]).to eq("127.0.0.1")
     end
 
     it "should parse the hostname from the second field" do
-      @provider.parse_line(@testline)[:name].should == "host"
+      expect(@provider.parse_line(@testline)[:name]).to eq("host")
     end
 
     it "should parse all host_aliases from the third field" do
-      @provider.parse_line(@testline)[:host_aliases].should == 'alias1 alias2 alias3'
+      expect(@provider.parse_line(@testline)[:host_aliases]).to eq('alias1 alias2 alias3')
     end
 
     it "should parse the comment after the first '#' character" do
-      @provider.parse_line(@testline)[:comment].should == 'A comment with a #-char'
+      expect(@provider.parse_line(@testline)[:comment]).to eq('A comment with a #-char')
     end
 
   end
@@ -137,7 +173,7 @@ describe provider_class do
         :ip     => '127.0.0.1',
         :ensure => :present
       )
-      genhost(host).should == "127.0.0.1\tlocalhost\n"
+      expect(genhost(host)).to eq("127.0.0.1\tlocalhost\n")
     end
 
     it "should be able to generate an entry with one alias" do
@@ -147,7 +183,7 @@ describe provider_class do
         :host_aliases => 'localhost',
         :ensure => :present
       )
-      genhost(host).should == "127.0.0.1\tlocalhost.localdomain\tlocalhost\n"
+      expect(genhost(host)).to eq("127.0.0.1\tlocalhost.localdomain\tlocalhost\n")
     end
 
     it "should be able to generate an entry with more than one alias" do
@@ -157,7 +193,7 @@ describe provider_class do
         :host_aliases => [ 'a1','a2','a3','a4' ],
         :ensure     => :present
       )
-      genhost(host).should == "192.0.0.1\thost\ta1 a2 a3 a4\n"
+      expect(genhost(host)).to eq("192.0.0.1\thost\ta1 a2 a3 a4\n")
     end
 
     it "should be able to generate a simple hostfile entry with comments" do
@@ -167,7 +203,7 @@ describe provider_class do
         :comment => 'Bazinga!',
         :ensure  => :present
       )
-      genhost(host).should == "127.0.0.1\tlocalhost\t# Bazinga!\n"
+      expect(genhost(host)).to eq("127.0.0.1\tlocalhost\t# Bazinga!\n")
     end
 
     it "should be able to generate an entry with one alias and a comment" do
@@ -178,7 +214,7 @@ describe provider_class do
         :comment => 'Bazinga!',
         :ensure => :present
       )
-      genhost(host).should == "127.0.0.1\tlocalhost.localdomain\tlocalhost\t# Bazinga!\n"
+      expect(genhost(host)).to eq("127.0.0.1\tlocalhost.localdomain\tlocalhost\t# Bazinga!\n")
     end
 
     it "should be able to generate an entry with more than one alias and a comment" do
@@ -189,7 +225,7 @@ describe provider_class do
         :comment      => 'Bazinga!',
         :ensure       => :present
       )
-      genhost(host).should == "192.0.0.1\thost\ta1 a2 a3 a4\t# Bazinga!\n"
+      expect(genhost(host)).to eq("192.0.0.1\thost\ta1 a2 a3 a4\t# Bazinga!\n")
     end
 
   end

data/spec/unit/provider/interface/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 the given interface data" do
       @device.expects(:interface).returns({ :description => "thisone", :mode => :access})
-      provider_class.lookup(@device, "Fa0").should == {:description => "thisone", :mode => :access }
+      expect(provider_class.lookup(@device, "Fa0")).to eq({:description => "thisone", :mode => :access })
     end
 
   end

data/spec/unit/provider/ldap_spec.rb

@@ -13,12 +13,12 @@ describe Puppet::Provider::Ldap do
     Puppet::Util::Ldap::Manager.expects(:new).returns manager
     @class.stubs :mk_resource_methods
     manager.expects(:manages).with(:one)
-    @class.manages(:one).should equal(manager)
-    @class.manager.should equal(manager)
+    expect(@class.manages(:one)).to equal(manager)
+    expect(@class.manager).to equal(manager)
   end
 
   it "should be able to prefetch instances from ldap" do
-    @class.should respond_to(:prefetch)
+    expect(@class).to respond_to(:prefetch)
   end
 
   it "should create its resource getter/setter methods when the manager is defined" do
@@ -26,11 +26,11 @@ describe Puppet::Provider::Ldap do
     Puppet::Util::Ldap::Manager.expects(:new).returns manager
     @class.expects :mk_resource_methods
     manager.stubs(:manages)
-    @class.manages(:one).should equal(manager)
+    expect(@class.manages(:one)).to equal(manager)
   end
 
   it "should have an instances method" do
-    @class.should respond_to(:instances)
+    expect(@class).to respond_to(:instances)
   end
 
   describe "when providing a list of instances" do
@@ -44,12 +44,12 @@ describe Puppet::Provider::Ldap do
       @class.expects(:new).with("two").returns(2)
       @class.expects(:new).with("three").returns(3)
 
-      @class.instances.should == [1,2,3]
+      expect(@class.instances).to eq([1,2,3])
     end
   end
 
   it "should have a prefetch method" do
-    @class.should respond_to(:prefetch)
+    expect(@class).to respond_to(:prefetch)
   end
 
   describe "when prefetching" do
@@ -108,13 +108,13 @@ describe Puppet::Provider::Ldap do
 
   describe "when being initialized" do
     it "should fail if no manager has been defined" do
-      lambda { @class.new }.should raise_error(Puppet::DevError)
+      expect { @class.new }.to raise_error(Puppet::DevError)
     end
 
     it "should fail if the manager is invalid" do
       manager = stub "manager", :valid? => false
       @class.stubs(:manager).returns manager
-      lambda { @class.new }.should raise_error(Puppet::DevError)
+      expect { @class.new }.to raise_error(Puppet::DevError)
     end
 
     describe "with a hash" do
@@ -132,19 +132,19 @@ describe Puppet::Provider::Ldap do
 
       it "should store a copy of the hash as its ldap_properties" do
         instance = @class.new(:one => :two)
-        instance.ldap_properties.should == {:one => :two}
+        expect(instance.ldap_properties).to eq({:one => :two})
       end
 
       it "should only store the first value of each value array for those attributes that do not match all values" do
         @property_class.expects(:array_matching).returns :first
         instance = @class.new(:one => %w{two three})
-        instance.properties.should == {:one => "two"}
+        expect(instance.properties).to eq({:one => "two"})
       end
 
       it "should store the whole value array for those attributes that match all values" do
         @property_class.expects(:array_matching).returns :all
         instance = @class.new(:one => %w{two three})
-        instance.properties.should == {:one => %w{two three}}
+        expect(instance.properties).to eq({:one => %w{two three}})
       end
 
       it "should only use the first value for attributes that are not properties" do
@@ -153,7 +153,7 @@ describe Puppet::Provider::Ldap do
         @property_class.stubs(:array_matching).returns :all
 
         instance = @class.new(:one => %w{two three}, :a => %w{b c})
-        instance.properties.should == {:one => %w{two three}, :a => "b"}
+        expect(instance.properties).to eq({:one => %w{two three}, :a => "b"})
       end
 
       it "should discard any properties not valid in the resource class" do
@@ -161,7 +161,7 @@ describe Puppet::Provider::Ldap do
         @property_class.stubs(:array_matching).returns :all
 
         instance = @class.new(:one => %w{two three}, :a => %w{b})
-        instance.properties.should == {:one => %w{two three}}
+        expect(instance.properties).to eq({:one => %w{two three}})
       end
     end
   end
@@ -178,25 +178,25 @@ describe Puppet::Provider::Ldap do
     end
 
     it "should have a method for creating the ldap entry" do
-      @instance.should respond_to(:create)
+      expect(@instance).to respond_to(:create)
     end
 
     it "should have a method for removing the ldap entry" do
-      @instance.should respond_to(:delete)
+      expect(@instance).to respond_to(:delete)
     end
 
     it "should have a method for returning the class's manager" do
-      @instance.manager.should equal(@manager)
+      expect(@instance.manager).to equal(@manager)
     end
 
     it "should indicate when the ldap entry already exists" do
       @instance = @class.new(:ensure => :present)
-      @instance.exists?.should be_true
+      expect(@instance.exists?).to be_truthy
     end
 
     it "should indicate when the ldap entry does not exist" do
       @instance = @class.new(:ensure => :absent)
-      @instance.exists?.should be_false
+      expect(@instance.exists?).to be_falsey
     end
 
     describe "is being flushed" do
@@ -221,7 +221,7 @@ describe Puppet::Provider::Ldap do
 
       it "should set its :ensure value to :present" do
         @instance.create
-        @instance.properties[:ensure].should == :present
+        expect(@instance.properties[:ensure]).to eq(:present)
       end
 
       it "should set all of the other attributes from the resource" do
@@ -229,15 +229,15 @@ describe Puppet::Provider::Ldap do
         @resource.expects(:should).with(:two).returns "twoval"
 
         @instance.create
-        @instance.properties[:one].should == "oneval"
-        @instance.properties[:two].should == "twoval"
+        expect(@instance.properties[:one]).to eq("oneval")
+        expect(@instance.properties[:two]).to eq("twoval")
       end
     end
 
     describe "is being deleted" do
       it "should set its :ensure value to :absent" do
         @instance.delete
-        @instance.properties[:ensure].should == :absent
+        expect(@instance.properties[:ensure]).to eq(:absent)
       end
     end
   end