puppet 3.8.7 → 4.0.0

data/spec/unit/util/http_proxy_spec.rb

@@ -8,53 +8,53 @@ describe Puppet::Util::HttpProxy do
 
   describe ".http_proxy_env" do
     it "should return nil if no environment variables" do
-      subject.http_proxy_env.should == nil
+      expect(subject.http_proxy_env).to eq(nil)
     end
 
     it "should return a URI::HTTP object if http_proxy env variable is set" do
       Puppet::Util.withenv('HTTP_PROXY' => host) do
-        subject.http_proxy_env.should == URI.parse(host)
+        expect(subject.http_proxy_env).to eq(URI.parse(host))
       end
     end
 
     it "should return a URI::HTTP object if HTTP_PROXY env variable is set" do
       Puppet::Util.withenv('HTTP_PROXY' => host) do
-        subject.http_proxy_env.should == URI.parse(host)
+        expect(subject.http_proxy_env).to eq(URI.parse(host))
       end
     end
 
     it "should return a URI::HTTP object with .host and .port if URI is given" do
       Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
-        subject.http_proxy_env.should == URI.parse("http://#{host}:#{port}")
+        expect(subject.http_proxy_env).to eq(URI.parse("http://#{host}:#{port}"))
       end
     end
 
     it "should return nil if proxy variable is malformed" do
       Puppet::Util.withenv('HTTP_PROXY' => 'this is not a valid URI') do
-        subject.http_proxy_env.should == nil
+        expect(subject.http_proxy_env).to eq(nil)
       end
     end
   end
 
   describe ".http_proxy_host" do
     it "should return nil if no proxy host in config or env" do
-      subject.http_proxy_host.should == nil
+      expect(subject.http_proxy_host).to eq(nil)
     end
 
     it "should return a proxy host if set in config" do
       Puppet.settings[:http_proxy_host] = host
-      subject.http_proxy_host.should == host
+      expect(subject.http_proxy_host).to eq(host)
     end
 
     it "should return nil if set to `none` in config" do
       Puppet.settings[:http_proxy_host] = 'none'
-      subject.http_proxy_host.should == nil
+      expect(subject.http_proxy_host).to eq(nil)
     end
 
     it "uses environment variable before puppet settings" do
       Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
         Puppet.settings[:http_proxy_host] = 'not.correct'
-        subject.http_proxy_host.should == host
+        expect(subject.http_proxy_host).to eq(host)
       end
     end
   end
@@ -62,19 +62,19 @@ describe Puppet::Util::HttpProxy do
   describe ".http_proxy_port" do
     it "should return a proxy port if set in environment" do
       Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
-        subject.http_proxy_port.should == port
+        expect(subject.http_proxy_port).to eq(port)
       end
     end
 
     it "should return a proxy port if set in config" do
       Puppet.settings[:http_proxy_port] = port
-      subject.http_proxy_port.should == port
+      expect(subject.http_proxy_port).to eq(port)
     end
 
     it "uses environment variable before puppet settings" do
       Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
         Puppet.settings[:http_proxy_port] = 7456
-        subject.http_proxy_port.should == port
+        expect(subject.http_proxy_port).to eq(port)
       end
     end
 
@@ -83,19 +83,19 @@ describe Puppet::Util::HttpProxy do
   describe ".http_proxy_user" do
     it "should return a proxy user if set in environment" do
       Puppet::Util.withenv('HTTP_PROXY' => "http://#{user}:#{password}@#{host}:#{port}") do
-        subject.http_proxy_user.should == user
+        expect(subject.http_proxy_user).to eq(user)
       end
     end
 
     it "should return a proxy user if set in config" do
       Puppet.settings[:http_proxy_user] = user
-      subject.http_proxy_user.should == user
+      expect(subject.http_proxy_user).to eq(user)
     end
 
     it "should use environment variable before puppet settings" do
       Puppet::Util.withenv('HTTP_PROXY' => "http://#{user}:#{password}@#{host}:#{port}") do
         Puppet.settings[:http_proxy_user] = 'clownpants'
-        subject.http_proxy_user.should == user
+        expect(subject.http_proxy_user).to eq(user)
       end
     end
 
@@ -104,20 +104,20 @@ describe Puppet::Util::HttpProxy do
   describe ".http_proxy_password" do
     it "should return a proxy password if set in environment" do
       Puppet::Util.withenv('HTTP_PROXY' => "http://#{user}:#{password}@#{host}:#{port}") do
-        subject.http_proxy_password.should == password
+        expect(subject.http_proxy_password).to eq(password)
       end
     end
 
     it "should return a proxy password if set in config" do
       Puppet.settings[:http_proxy_user] = user
       Puppet.settings[:http_proxy_password] = password
-      subject.http_proxy_password.should == password
+      expect(subject.http_proxy_password).to eq(password)
     end
 
     it "should use environment variable before puppet settings" do
       Puppet::Util.withenv('HTTP_PROXY' => "http://#{user}:#{password}@#{host}:#{port}") do
         Puppet.settings[:http_proxy_password] = 'clownpants'
-        subject.http_proxy_password.should == password
+        expect(subject.http_proxy_password).to eq(password)
       end
     end
 

data/spec/unit/util/inifile_spec.rb

@@ -470,11 +470,11 @@ describe Puppet::Util::IniConfig::FileCollection do
     end
 
     it "is true if a section with the given name is defined" do
-      expect(subject.include?('sect_a1')).to be_true
+      expect(subject.include?('sect_a1')).to be_truthy
     end
 
     it "is false if a section with the given name can't be found" do
-      expect(subject.include?('nonexistent')).to be_false
+      expect(subject.include?('nonexistent')).to be_falsey
     end
   end
 

data/spec/unit/util/json_lockfile_spec.rb

@@ -17,7 +17,7 @@ describe Puppet::Util::JsonLockfile do
       data = { "foo" => "foofoo", "bar" => "barbar" }
       @lock.lock(data)
 
-      PSON.parse(File.read(@lockfile)).should == data
+      expect(PSON.parse(File.read(@lockfile))).to eq(data)
     end
   end
 

data/spec/unit/util/ldap/connection_spec.rb

@@ -34,25 +34,25 @@ describe Puppet::Util::Ldap::Connection do
 
   describe "when creating connections" do
     it "should require the host and port" do
-      lambda { Puppet::Util::Ldap::Connection.new("myhost") }.should raise_error(ArgumentError)
+      expect { Puppet::Util::Ldap::Connection.new("myhost") }.to raise_error(ArgumentError)
     end
 
     it "should allow specification of a user and password" do
-      lambda { Puppet::Util::Ldap::Connection.new("myhost", "myport", :user => "blah", :password => "boo") }.should_not raise_error
+      expect { Puppet::Util::Ldap::Connection.new("myhost", "myport", :user => "blah", :password => "boo") }.not_to raise_error
     end
 
     it "should allow specification of ssl" do
-      lambda { Puppet::Util::Ldap::Connection.new("myhost", "myport", :ssl => :tsl) }.should_not raise_error
+      expect { Puppet::Util::Ldap::Connection.new("myhost", "myport", :ssl => :tsl) }.not_to raise_error
     end
 
     it "should support requiring a new connection" do
-      lambda { Puppet::Util::Ldap::Connection.new("myhost", "myport", :reset => true) }.should_not raise_error
+      expect { Puppet::Util::Ldap::Connection.new("myhost", "myport", :reset => true) }.not_to raise_error
     end
 
     it "should fail if ldap is unavailable" do
       Puppet.features.expects(:ldap?).returns(false)
 
-      lambda { Puppet::Util::Ldap::Connection.new("host", "port") }.should raise_error(Puppet::Error)
+      expect { Puppet::Util::Ldap::Connection.new("host", "port") }.to raise_error(Puppet::Error)
     end
 
     it "should use neither ssl nor tls by default" do
@@ -109,7 +109,7 @@ describe Puppet::Util::Ldap::Connection do
   end
 
   it "should have a class-level method for creating a default connection" do
-    Puppet::Util::Ldap::Connection.should respond_to(:instance)
+    expect(Puppet::Util::Ldap::Connection).to respond_to(:instance)
   end
 
   describe "when creating a default connection" do

data/spec/unit/util/ldap/generator_spec.rb

@@ -9,12 +9,12 @@ describe Puppet::Util::Ldap::Generator do
   end
 
   it "should require a parameter name at initialization" do
-    lambda { Puppet::Util::Ldap::Generator.new }.should raise_error
+    expect { Puppet::Util::Ldap::Generator.new }.to raise_error
   end
 
   it "should always return its name as a string" do
     g = Puppet::Util::Ldap::Generator.new(:myname)
-    g.name.should == "myname"
+    expect(g.name).to eq("myname")
   end
 
   it "should provide a method for declaring the source parameter" do
@@ -23,28 +23,28 @@ describe Puppet::Util::Ldap::Generator do
 
   it "should always return a set source as a string" do
     @generator.from(:dos)
-    @generator.source.should == "dos"
+    expect(@generator.source).to eq("dos")
   end
 
   it "should return the source as nil if there is no source" do
-    @generator.source.should be_nil
+    expect(@generator.source).to be_nil
   end
 
   it "should return itself when declaring the source" do
-    @generator.from(:dos).should equal(@generator)
+    expect(@generator.from(:dos)).to equal(@generator)
   end
 
   it "should run the provided block when asked to generate the value" do
     @generator.with { "yayness" }
-    @generator.generate.should == "yayness"
+    expect(@generator.generate).to eq("yayness")
   end
 
   it "should pass in any provided value to the block" do
     @generator.with { |value| value.upcase }
-    @generator.generate("myval").should == "MYVAL"
+    expect(@generator.generate("myval")).to eq("MYVAL")
   end
 
   it "should return itself when declaring the code used for generating" do
-    @generator.with { |value| value.upcase }.should equal(@generator)
+    expect(@generator.with { |value| value.upcase }).to equal(@generator)
   end
 end

data/spec/unit/util/ldap/manager_spec.rb

@@ -24,39 +24,39 @@ describe Puppet::Util::Ldap::Manager do
   end
 
   it "should return self when specifying objectclasses" do
-    @manager.manages(:one, :two).should equal(@manager)
+    expect(@manager.manages(:one, :two)).to equal(@manager)
   end
 
   it "should allow specification of what objectclasses are managed" do
-    @manager.manages(:one, :two).objectclasses.should == [:one, :two]
+    expect(@manager.manages(:one, :two).objectclasses).to eq([:one, :two])
   end
 
   it "should return self when specifying the relative base" do
-    @manager.at("yay").should equal(@manager)
+    expect(@manager.at("yay")).to equal(@manager)
   end
 
   it "should allow specification of the relative base" do
-    @manager.at("yay").location.should == "yay"
+    expect(@manager.at("yay").location).to eq("yay")
   end
 
   it "should return self when specifying the attribute map" do
-    @manager.maps(:one => :two).should equal(@manager)
+    expect(@manager.maps(:one => :two)).to equal(@manager)
   end
 
   it "should allow specification of the rdn attribute" do
-    @manager.named_by(:uid).rdn.should == :uid
+    expect(@manager.named_by(:uid).rdn).to eq(:uid)
   end
 
   it "should allow specification of the attribute map" do
-    @manager.maps(:one => :two).puppet2ldap.should == {:one => :two}
+    expect(@manager.maps(:one => :two).puppet2ldap).to eq({:one => :two})
   end
 
   it "should have a no-op 'and' method that just returns self" do
-    @manager.and.should equal(@manager)
+    expect(@manager.and).to equal(@manager)
   end
 
   it "should allow specification of generated attributes" do
-    @manager.generates(:thing).should be_instance_of(Puppet::Util::Ldap::Generator)
+    expect(@manager.generates(:thing)).to be_instance_of(Puppet::Util::Ldap::Generator)
   end
 
   describe "when generating attributes" do
@@ -72,7 +72,7 @@ describe Puppet::Util::Ldap::Manager do
     end
 
     it "should return the generator from the :generates method" do
-      @manager.generates(:myparam).should equal(@generator)
+      expect(@manager.generates(:myparam)).to equal(@generator)
     end
 
     it "should not replace already present values" do
@@ -83,7 +83,7 @@ describe Puppet::Util::Ldap::Manager do
 
       @manager.generate attrs
 
-      attrs["myparam"].should == "testing"
+      expect(attrs["myparam"]).to eq("testing")
     end
 
     it "should look for the parameter as a string, not a symbol" do
@@ -92,12 +92,12 @@ describe Puppet::Util::Ldap::Manager do
       attrs = {"one" => "yay"}
       @manager.generate attrs
 
-      attrs["myparam"].should == %w{double yay}
+      expect(attrs["myparam"]).to eq(%w{double yay})
     end
 
     it "should fail if a source is specified and no source value is not defined" do
       @manager.generates(:myparam)
-      lambda { @manager.generate "two" => "yay" }.should raise_error(ArgumentError)
+      expect { @manager.generate "two" => "yay" }.to raise_error(ArgumentError)
     end
 
     it "should use the source value to generate the new value if a source attribute is specified" do
@@ -119,7 +119,7 @@ describe Puppet::Util::Ldap::Manager do
 
       attrs = {"one" => "two"}
       @manager.generate(attrs)
-      attrs["myparam"].should == ["test"]
+      expect(attrs["myparam"]).to eq(["test"])
     end
 
     it "should add the result to the passed-in attribute hash" do
@@ -128,90 +128,90 @@ describe Puppet::Util::Ldap::Manager do
 
       attrs = {"one" => "two"}
       @manager.generate(attrs)
-      attrs["myparam"].should == %w{test}
+      expect(attrs["myparam"]).to eq(%w{test})
     end
   end
 
   it "should be considered invalid if it is missing a location" do
     @manager.manages :me
     @manager.maps :me => :you
-    @manager.should_not be_valid
+    expect(@manager).not_to be_valid
   end
 
   it "should be considered invalid if it is missing an objectclass list" do
     @manager.maps :me => :you
     @manager.at "ou=yayness"
-    @manager.should_not be_valid
+    expect(@manager).not_to be_valid
   end
 
   it "should be considered invalid if it is missing an attribute map" do
     @manager.manages :me
     @manager.at "ou=yayness"
-    @manager.should_not be_valid
+    expect(@manager).not_to be_valid
   end
 
   it "should be considered valid if it has an attribute map, location, and objectclass list" do
     @manager.maps :me => :you
     @manager.manages :me
     @manager.at "ou=yayness"
-    @manager.should be_valid
+    expect(@manager).to be_valid
   end
 
   it "should calculate an instance's dn using the :ldapbase setting and the relative base" do
     Puppet[:ldapbase] = "dc=testing"
     @manager.at "ou=mybase"
-    @manager.dn("me").should == "cn=me,ou=mybase,dc=testing"
+    expect(@manager.dn("me")).to eq("cn=me,ou=mybase,dc=testing")
   end
 
   it "should use the specified rdn when calculating an instance's dn" do
     Puppet[:ldapbase] = "dc=testing"
     @manager.named_by :uid
     @manager.at "ou=mybase"
-    @manager.dn("me").should =~ /^uid=me/
+    expect(@manager.dn("me")).to match(/^uid=me/)
   end
 
   it "should calculate its base using the :ldapbase setting and the relative base" do
     Puppet[:ldapbase] = "dc=testing"
     @manager.at "ou=mybase"
-    @manager.base.should == "ou=mybase,dc=testing"
+    expect(@manager.base).to eq("ou=mybase,dc=testing")
   end
 
   describe "when generating its search filter" do
     it "should using a single 'objectclass=<name>' filter if a single objectclass is specified" do
       @manager.manages("testing")
-      @manager.filter.should == "objectclass=testing"
+      expect(@manager.filter).to eq("objectclass=testing")
     end
 
     it "should create an LDAP AND filter if multiple objectclasses are specified" do
       @manager.manages "testing", "okay", "done"
-      @manager.filter.should == "(&(objectclass=testing)(objectclass=okay)(objectclass=done))"
+      expect(@manager.filter).to eq("(&(objectclass=testing)(objectclass=okay)(objectclass=done))")
     end
   end
 
   it "should have a method for converting a Puppet attribute name to an LDAP attribute name as a string" do
     @manager.maps :puppet_attr => :ldap_attr
-    @manager.ldap_name(:puppet_attr).should == "ldap_attr"
+    expect(@manager.ldap_name(:puppet_attr)).to eq("ldap_attr")
   end
 
   it "should have a method for converting an LDAP attribute name to a Puppet attribute name" do
     @manager.maps :puppet_attr => :ldap_attr
-    @manager.puppet_name(:ldap_attr).should == :puppet_attr
+    expect(@manager.puppet_name(:ldap_attr)).to eq(:puppet_attr)
   end
 
   it "should have a :create method for creating ldap entries" do
-    @manager.should respond_to(:create)
+    expect(@manager).to respond_to(:create)
   end
 
   it "should have a :delete method for deleting ldap entries" do
-    @manager.should respond_to(:delete)
+    expect(@manager).to respond_to(:delete)
   end
 
   it "should have a :modify method for modifying ldap entries" do
-    @manager.should respond_to(:modify)
+    expect(@manager).to respond_to(:modify)
   end
 
   it "should have a method for finding an entry by name in ldap" do
-    @manager.should respond_to(:find)
+    expect(@manager).to respond_to(:find)
   end
 
   describe "when converting ldap entries to hashes for providers" do
@@ -222,23 +222,23 @@ describe Puppet::Util::Ldap::Manager do
     end
 
     it "should set the name to the short portion of the dn" do
-      @result[:name].should == "one"
+      expect(@result[:name]).to eq("one")
     end
 
     it "should remove the objectclasses" do
-      @result["objectclass"].should be_nil
+      expect(@result["objectclass"]).to be_nil
     end
 
     it "should remove any attributes that are not mentioned in the map" do
-      @result["three"].should be_nil
+      expect(@result["three"]).to be_nil
     end
 
     it "should rename convert to symbols all attributes to their puppet names" do
-      @result[:uno].should == %w{two}
+      expect(@result[:uno]).to eq(%w{two})
     end
 
     it "should set the value of all unset puppet attributes as :absent" do
-      @result[:dos].should == :absent
+      expect(@result[:dos]).to eq(:absent)
     end
   end
 
@@ -326,7 +326,7 @@ describe Puppet::Util::Ldap::Manager do
 
     it "should close the connection even if there's an exception in the passed block" do
       @conn.expects(:close)
-      lambda { @manager.connect { |c| raise ArgumentError } }.should raise_error(ArgumentError)
+      expect { @manager.connect { |c| raise ArgumentError } }.to raise_error(ArgumentError)
     end
   end
 
@@ -428,7 +428,7 @@ describe Puppet::Util::Ldap::Manager do
         @manager.expects(:dn).with("myname").returns "mydn"
         @conn.expects(:search2).raises LDAP::ResultError
 
-        @manager.find("myname").should be_nil
+        expect(@manager.find("myname")).to be_nil
       end
 
       it "should return a converted provider hash if the result is found" do
@@ -438,7 +438,7 @@ describe Puppet::Util::Ldap::Manager do
 
         @manager.expects(:entry2provider).with(result).returns "myprovider"
 
-        @manager.find("myname").should == "myprovider"
+        expect(@manager.find("myname")).to eq("myprovider")
       end
     end
 
@@ -477,7 +477,7 @@ describe Puppet::Util::Ldap::Manager do
       it "should return nil if no result is found" do
         @conn.expects(:search2)
 
-        @manager.search.should be_nil
+        expect(@manager.search).to be_nil
       end
 
       it "should return an array of the found results converted to provider hashes" do
@@ -487,7 +487,7 @@ describe Puppet::Util::Ldap::Manager do
 
         @manager.expects(:entry2provider).with(one).returns "myprov"
 
-        @manager.search.should == ["myprov"]
+        expect(@manager.search).to eq(["myprov"])
       end
     end
   end

data/spec/unit/util/lockfile_spec.rb

@@ -41,18 +41,18 @@ describe Puppet::Util::Lockfile do
 
   describe "#lock" do
     it "should return true if it successfully locked" do
-      @lock.lock.should be_true
+      expect(@lock.lock).to be_truthy
     end
 
     it "should return false if already locked" do
       @lock.lock
-      @lock.lock.should be_false
+      expect(@lock.lock).to be_falsey
     end
 
     it "should create a lock file" do
       @lock.lock
 
-      Puppet::FileSystem.exist?(@lockfile).should be_true
+      expect(Puppet::FileSystem.exist?(@lockfile)).to be_truthy
     end
 
     # We test simultaneous locks using fork which isn't supported on Windows.
@@ -65,8 +65,8 @@ describe Puppet::Util::Lockfile do
         @lock.unlock
 
         # Confirm one fork returned true and everyone else false.
-        (results - [true]).size.should == forks - 1
-        (results - [false]).size.should == 1
+        expect((results - [true]).size).to eq(forks - 1)
+        expect((results - [false]).size).to eq(1)
       end
     end
 
@@ -74,45 +74,45 @@ describe Puppet::Util::Lockfile do
       data = "foofoo barbar"
       @lock.lock(data)
 
-      File.read(@lockfile).should == data
+      expect(File.read(@lockfile)).to eq(data)
     end
   end
 
   describe "#unlock" do
     it "should return true when unlocking" do
       @lock.lock
-      @lock.unlock.should be_true
+      expect(@lock.unlock).to be_truthy
     end
 
     it "should return false when not locked" do
-      @lock.unlock.should be_false
+      expect(@lock.unlock).to be_falsey
     end
 
     it "should clear the lock file" do
       File.open(@lockfile, 'w') { |fd| fd.print("locked") }
       @lock.unlock
-      Puppet::FileSystem.exist?(@lockfile).should be_false
+      expect(Puppet::FileSystem.exist?(@lockfile)).to be_falsey
     end
   end
 
   it "should be locked when locked" do
     @lock.lock
-    @lock.should be_locked
+    expect(@lock).to be_locked
   end
 
   it "should not be locked when not locked" do
-    @lock.should_not be_locked
+    expect(@lock).not_to be_locked
   end
 
   it "should not be locked when unlocked" do
     @lock.lock
     @lock.unlock
-    @lock.should_not be_locked
+    expect(@lock).not_to be_locked
   end
 
   it "should return the lock data" do
     data = "foofoo barbar"
     @lock.lock(data)
-    @lock.lock_data.should == data
+    expect(@lock.lock_data).to eq(data)
   end
 end