puppet 3.8.7 → 4.0.0

data/spec/unit/indirector/ldap_spec.rb

@@ -36,13 +36,13 @@ describe Puppet::Indirector::Ldap do
     end
 
     it "should fail if no block is passed to the ldapsearch method" do
-      proc { @searcher.ldapsearch("blah") }.should raise_error(ArgumentError)
+      expect { @searcher.ldapsearch("blah") }.to raise_error(ArgumentError)
     end
 
     it "should use the results of the ldapbase method as the ldap search base" do
       @searcher.stubs(:search_base).returns("mybase")
       @connection.expects(:search).with do |*args|
-        args[0].should == "mybase"
+        expect(args[0]).to eq("mybase")
         true
       end
       @searcher.find @request
@@ -51,13 +51,13 @@ describe Puppet::Indirector::Ldap do
     it "should default to the value of the :search_base setting as the result of the ldapbase method" do
       Puppet[:ldapbase] = "myldapbase"
       searcher = @ldap_class.new
-      searcher.search_base.should == "myldapbase"
+      expect(searcher.search_base).to eq("myldapbase")
     end
 
     it "should use the results of the :search_attributes method as the list of attributes to return" do
       @searcher.stubs(:search_attributes).returns(:myattrs)
       @connection.expects(:search).with do |*args|
-        args[3].should == :myattrs
+        expect(args[3]).to eq(:myattrs)
         true
       end
       @searcher.find @request
@@ -65,7 +65,7 @@ describe Puppet::Indirector::Ldap do
 
     it "should use depth 2 when searching" do
       @connection.expects(:search).with do |*args|
-        args[1].should == 2
+        expect(args[1]).to eq(2)
         true
       end
       @searcher.find @request
@@ -98,36 +98,36 @@ describe Puppet::Indirector::Ldap do
         count += 1
         raise ArgumentError, "yay"
       end
-      proc { @searcher.find(@request) }.should raise_error(Puppet::Error)
-      count.should == 2
+      expect { @searcher.find(@request) }.to raise_error(Puppet::Error)
+      expect(count).to eq(2)
     end
 
     it "should return true if an entry is found" do
       @connection.expects(:search).yields("result")
-      @searcher.ldapsearch("whatever") { |r| }.should be_true
+      expect(@searcher.ldapsearch("whatever") { |r| }).to be_truthy
     end
   end
 
   describe "when connecting to ldap", :if => Puppet.features.ldap? do
     it "should create and start a Util::Ldap::Connection instance" do
-      conn = mock 'connection', :connection => "myconn", :start => nil
+      conn = double 'connection', :connection => "myconn", :start => nil
       Puppet::Util::Ldap::Connection.expects(:instance).returns conn
 
-      @searcher.connection.should == "myconn"
+      expect(@searcher.connection).to eq("myconn")
     end
 
     it "should only create the ldap connection when asked for it the first time" do
-      conn = mock 'connection', :connection => "myconn", :start => nil
+      conn = double 'connection', :connection => "myconn", :start => nil
       Puppet::Util::Ldap::Connection.expects(:instance).returns conn
 
       @searcher.connection
     end
 
     it "should cache the connection" do
-      conn = mock 'connection', :connection => "myconn", :start => nil
+      conn = double 'connection', :connection => "myconn", :start => nil
       Puppet::Util::Ldap::Connection.expects(:instance).returns conn
 
-      @searcher.connection.should equal(@searcher.connection)
+      expect(@searcher.connection).to equal(@searcher.connection)
     end
   end
 

data/spec/unit/indirector/msgpack_spec.rb

@@ -19,19 +19,19 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
     it "uses the :server_datadir setting if this is the master" do
       Puppet.run_mode.stubs(:master?).returns(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.msgpack')
-      subject.path('testing').should == expected
+      expect(subject.path('testing')).to eq(expected)
     end
 
     it "uses the :client_datadir setting if this is not the master" do
       Puppet.run_mode.stubs(:master?).returns(false)
       expected = File.join(Puppet[:client_datadir], 'indirector_testing', 'testing.msgpack')
-      subject.path('testing').should == expected
+      expect(subject.path('testing')).to eq(expected)
     end
 
     it "overrides the default extension with a supplied value" do
       Puppet.run_mode.stubs(:master?).returns(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.not-msgpack')
-      subject.path('testing', '.not-msgpack').should == expected
+      expect(subject.path('testing', '.not-msgpack')).to eq(expected)
     end
 
     ['../foo', '..\\foo', './../foo', '.\\..\\foo',
@@ -66,14 +66,14 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
 
     it "data saves and then loads again correctly" do
       subject.save(indirection.request(:save, 'example', model.new('banana')))
-      subject.find(indirection.request(:find, 'example', nil)).value.should == 'banana'
+      expect(subject.find(indirection.request(:find, 'example', nil)).value).to eq('banana')
     end
 
     context "#find" do
       let :request do indirection.request(:find, 'example', nil) end
 
       it "returns nil if the file doesn't exist" do
-        subject.find(request).should be_nil
+        expect(subject.find(request)).to be_nil
       end
 
       it "raises a descriptive error when the file can't be read" do
@@ -97,8 +97,8 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
       it "should return an instance of the indirected object when valid" do
         with_content(model.new(1).to_msgpack) do
           instance = subject.find(request)
-          instance.should be_an_instance_of model
-          instance.value.should == 1
+          expect(instance).to be_an_instance_of model
+          expect(instance.value).to eq(1)
         end
       end
     end
@@ -110,7 +110,7 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
       it "should save the instance of the request as MessagePack to disk" do
         subject.save(request)
         content = File.read(file)
-        MessagePack.unpack(content)['value'].should == 4
+        expect(MessagePack.unpack(content)['value']).to eq(4)
       end
 
       it "should create the indirection directory if required" do
@@ -119,7 +119,7 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
 
         subject.save(request)
 
-        File.should be_directory(target)
+        expect(File).to be_directory(target)
       end
     end
 
@@ -130,12 +130,12 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
         with_content('hello') do
           subject.destroy(request)
         end
-        Puppet::FileSystem.exist?(file).should be_false
+        expect(Puppet::FileSystem.exist?(file)).to be_falsey
       end
 
       it "silently succeeds when files don't exist" do
         Puppet::FileSystem.unlink(file) rescue nil
-        subject.destroy(request).should be_true
+        expect(subject.destroy(request)).to be_truthy
       end
 
       it "raises an informative error for other failures" do
@@ -166,26 +166,26 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
     end
 
     it "returns an empty array when nothing matches the key as a glob" do
-      subject.search(request('*')).should == []
+      expect(subject.search(request('*'))).to eq([])
     end
 
     it "returns an array with one item if one item matches" do
       create_file('foo.msgpack', 'foo')
       create_file('bar.msgpack', 'bar')
-      subject.search(request('f*')).map(&:value).should == ['foo']
+      expect(subject.search(request('f*')).map(&:value)).to eq(['foo'])
     end
 
     it "returns an array of items when more than one item matches" do
       create_file('foo.msgpack', 'foo')
       create_file('bar.msgpack', 'bar')
       create_file('baz.msgpack', 'baz')
-      subject.search(request('b*')).map(&:value).should =~ ['bar', 'baz']
+      expect(subject.search(request('b*')).map(&:value)).to match_array(['bar', 'baz'])
     end
 
     it "only items with the .msgpack extension" do
       create_file('foo.msgpack', 'foo-msgpack')
       create_file('foo.msgpack~', 'foo-backup')
-      subject.search(request('f*')).map(&:value).should == ['foo-msgpack']
+      expect(subject.search(request('f*')).map(&:value)).to eq(['foo-msgpack'])
     end
   end
 end

data/spec/unit/indirector/node/exec_spec.rb

@@ -14,16 +14,19 @@ describe Puppet::Node::Exec do
   describe "when constructing the command to run" do
     it "should use the external_node script as the command" do
       Puppet[:external_nodes] = "/bin/echo"
-      @searcher.command.should == %w{/bin/echo}
+      expect(@searcher.command).to eq(%w{/bin/echo})
     end
 
     it "should throw an exception if no external node command is set" do
       Puppet[:external_nodes] = "none"
-      proc { @searcher.find(stub('request', :key => "foo")) }.should raise_error(ArgumentError)
+      expect { @searcher.find(stub('request', :key => "foo")) }.to raise_error(ArgumentError)
     end
   end
 
   describe "when handling the results of the command" do
+    let(:testing_env) { Puppet::Node::Environment.create(:testing, []) }
+    let(:other_env) { Puppet::Node::Environment.create(:other, []) }
+
     before do
       @name = "yay"
       @node = Puppet::Node.new(@name)
@@ -39,21 +42,29 @@ describe Puppet::Node::Exec do
       @request = Puppet::Indirector::Request.new(:node, :find, @name, nil)
     end
 
+    around do |example|
+      envs = Puppet::Environments::Static.new(testing_env, other_env)
+
+      Puppet.override(:environments => envs) do
+        example.run
+      end
+    end
+
     it "should translate the YAML into a Node instance" do
       # Use an empty hash
-      @searcher.find(@request).should equal(@node)
+      expect(@searcher.find(@request)).to equal(@node)
     end
 
     it "should set the resulting parameters as the node parameters" do
       @result[:parameters] = {"a" => "b", "c" => "d"}
       @searcher.find(@request)
-      @node.parameters.should == {"a" => "b", "c" => "d"}
+      expect(@node.parameters).to eq({"a" => "b", "c" => "d"})
     end
 
     it "should set the resulting classes as the node classes" do
       @result[:classes] = %w{one two}
       @searcher.find(@request)
-      @node.classes.should == [ 'one', 'two' ]
+      expect(@node.classes).to eq([ 'one', 'two' ])
     end
 
     it "should merge the node's facts with its parameters" do
@@ -62,15 +73,15 @@ describe Puppet::Node::Exec do
     end
 
     it "should set the node's environment if one is provided" do
-      @result[:environment] = "yay"
+      @result[:environment] = "testing"
       @searcher.find(@request)
-      @node.environment.to_s.should == 'yay'
+      expect(@node.environment.name).to eq(:testing)
     end
 
     it "should set the node's environment based on the request if not otherwise provided" do
-      @request.environment = "boo"
+      @request.environment = "other"
       @searcher.find(@request)
-      @node.environment.to_s.should == 'boo'
+      expect(@node.environment.name).to eq(:other)
     end
   end
 end

data/spec/unit/indirector/node/ldap_spec.rb

@@ -28,7 +28,7 @@ describe Puppet::Node::Ldap do
       node_indirection.expects(:ldapsearch).with("(&(objectclass=puppetClient)(cn=#{nodename}))").yields entry
       myhash = {"myhash" => true}
       node_indirection.expects(:entry2hash).with(entry).returns myhash
-      node_indirection.name2hash(nodename).should == myhash
+      expect(node_indirection.name2hash(nodename)).to eq(myhash)
     end
 
     # This heavily tests our entry2hash method, so we don't have to stub out the stupid entry information any more.
@@ -39,20 +39,20 @@ describe Puppet::Node::Ldap do
       end
 
       it "should convert the entry to a hash" do
-        node_indirection.entry2hash(@entry).should be_instance_of(Hash)
+        expect(node_indirection.entry2hash(@entry)).to be_instance_of(Hash)
       end
 
       it "should add the entry's common name to the hash if fqdn if false" do
-        node_indirection.entry2hash(@entry,fqdn = false)[:name].should == "mynode"
+        expect(node_indirection.entry2hash(@entry,fqdn = false)[:name]).to eq("mynode")
       end
 
       it "should add the entry's fqdn name to the hash if fqdn if true" do
-        node_indirection.entry2hash(@entry,fqdn = true)[:name].should == "mynode.madstop.com"
+        expect(node_indirection.entry2hash(@entry,fqdn = true)[:name]).to eq("mynode.madstop.com")
       end
 
       it "should add all of the entry's classes to the hash" do
         @entry.stubs(:vals).with("puppetclass").returns %w{one two}
-        node_indirection.entry2hash(@entry)[:classes].should == %w{one two}
+        expect(node_indirection.entry2hash(@entry)[:classes]).to eq(%w{one two})
       end
 
       it "should deduplicate class values" do
@@ -60,65 +60,65 @@ describe Puppet::Node::Ldap do
         node_indirection.stubs(:class_attributes).returns(%w{one two})
         @entry.stubs(:vals).with("one").returns(%w{a b})
         @entry.stubs(:vals).with("two").returns(%w{b c})
-        node_indirection.entry2hash(@entry)[:classes].should == %w{a b c}
+        expect(node_indirection.entry2hash(@entry)[:classes]).to eq(%w{a b c})
       end
 
       it "should add the entry's environment to the hash" do
         @entry.stubs(:to_hash).returns("environment" => %w{production})
-        node_indirection.entry2hash(@entry)[:environment].should == "production"
+        expect(node_indirection.entry2hash(@entry)[:environment]).to eq("production")
       end
 
       it "should add all stacked parameters as parameters in the hash" do
         @entry.stubs(:vals).with("puppetvar").returns(%w{one=two three=four})
         result = node_indirection.entry2hash(@entry)
-        result[:parameters]["one"].should == "two"
-        result[:parameters]["three"].should == "four"
+        expect(result[:parameters]["one"]).to eq("two")
+        expect(result[:parameters]["three"]).to eq("four")
       end
 
       it "should not add the stacked parameter as a normal parameter" do
         @entry.stubs(:vals).with("puppetvar").returns(%w{one=two three=four})
         @entry.stubs(:to_hash).returns("puppetvar" => %w{one=two three=four})
-        node_indirection.entry2hash(@entry)[:parameters]["puppetvar"].should be_nil
+        expect(node_indirection.entry2hash(@entry)[:parameters]["puppetvar"]).to be_nil
       end
 
       it "should add all other attributes as parameters in the hash" do
         @entry.stubs(:to_hash).returns("foo" => %w{one two})
-        node_indirection.entry2hash(@entry)[:parameters]["foo"].should == %w{one two}
+        expect(node_indirection.entry2hash(@entry)[:parameters]["foo"]).to eq(%w{one two})
       end
 
       it "should return single-value parameters as strings, not arrays" do
         @entry.stubs(:to_hash).returns("foo" => %w{one})
-        node_indirection.entry2hash(@entry)[:parameters]["foo"].should == "one"
+        expect(node_indirection.entry2hash(@entry)[:parameters]["foo"]).to eq("one")
       end
 
       it "should convert 'true' values to the boolean 'true'" do
         @entry.stubs(:to_hash).returns({"one" => ["true"]})
-        node_indirection.entry2hash(@entry)[:parameters]["one"].should == true
+        expect(node_indirection.entry2hash(@entry)[:parameters]["one"]).to eq(true)
       end
 
       it "should convert 'false' values to the boolean 'false'" do
         @entry.stubs(:to_hash).returns({"one" => ["false"]})
-        node_indirection.entry2hash(@entry)[:parameters]["one"].should == false
+        expect(node_indirection.entry2hash(@entry)[:parameters]["one"]).to eq(false)
       end
 
       it "should convert 'true' values to the boolean 'true' inside an array" do
         @entry.stubs(:to_hash).returns({"one" => ["true", "other"]})
-        node_indirection.entry2hash(@entry)[:parameters]["one"].should == [true, "other"]
+        expect(node_indirection.entry2hash(@entry)[:parameters]["one"]).to eq([true, "other"])
       end
 
       it "should convert 'false' values to the boolean 'false' inside an array" do
         @entry.stubs(:to_hash).returns({"one" => ["false", "other"]})
-        node_indirection.entry2hash(@entry)[:parameters]["one"].should == [false, "other"]
+        expect(node_indirection.entry2hash(@entry)[:parameters]["one"]).to eq([false, "other"])
       end
 
       it "should add the parent's name if present" do
         @entry.stubs(:vals).with("parentnode").returns(%w{foo})
-        node_indirection.entry2hash(@entry)[:parent].should == "foo"
+        expect(node_indirection.entry2hash(@entry)[:parent]).to eq("foo")
       end
 
       it "should fail if more than one parent is specified" do
         @entry.stubs(:vals).with("parentnode").returns(%w{foo})
-        node_indirection.entry2hash(@entry)[:parent].should == "foo"
+        expect(node_indirection.entry2hash(@entry)[:parent]).to eq("foo")
       end
     end
 
@@ -142,12 +142,12 @@ describe Puppet::Node::Ldap do
 
     it "should return nil if no results are found in ldap" do
       node_indirection.stubs(:name2hash).returns nil
-      node_indirection.find(request).should be_nil
+      expect(node_indirection.find(request)).to be_nil
     end
 
     it "should return a node object if results are found in ldap" do
       node_indirection.stubs(:name2hash).returns({})
-      node_indirection.find(request).should be
+      expect(node_indirection.find(request)).to be
     end
 
     describe "and node information is found in LDAP" do
@@ -160,19 +160,19 @@ describe Puppet::Node::Ldap do
         node_indirection.expects(:name2hash).with(nodename).returns nil
         node_indirection.expects(:name2hash).with("mynode").returns @result
 
-        node_indirection.find(request).name.should == nodename
+        expect(node_indirection.find(request).name).to eq(nodename)
       end
 
       it "should add any classes from ldap" do
         classes = %w{a b c d}
         @result[:classes] = classes
-        node_indirection.find(request).classes.should == classes
+        expect(node_indirection.find(request).classes).to eq(classes)
       end
 
       it "should add all entry attributes as node parameters" do
         params = {"one" => "two", "three" => "four"}
         @result[:parameters] = params
-        node_indirection.find(request).parameters.should include(params)
+        expect(node_indirection.find(request).parameters).to include(params)
       end
 
       it "should set the node's environment to the environment of the results" do
@@ -181,14 +181,14 @@ describe Puppet::Node::Ldap do
         @result[:environment] = "local_test"
 
         Puppet.override(:environments => Puppet::Environments::Static.new(result_env)) do
-          node_indirection.find(request).environment.should == result_env
+          expect(node_indirection.find(request).environment).to eq(result_env)
         end
       end
 
       it "should retain false parameter values" do
         @result[:parameters] = {}
         @result[:parameters]["one"] = false
-        node_indirection.find(request).parameters.should include({"one" => false})
+        expect(node_indirection.find(request).parameters).to include({"one" => false})
       end
 
       it "should merge the node's facts after the parameters from ldap are assigned" do
@@ -199,7 +199,7 @@ describe Puppet::Node::Ldap do
         # Node implements its own merge so that an existing param takes
         # precedence over facts. We get the same result here by merging params
         # into facts
-        node_indirection.find(request).parameters.should == facts.values.merge(params)
+        expect(node_indirection.find(request).parameters).to eq(facts.values.merge(params))
       end
 
       describe "and a parent node is specified" do
@@ -228,7 +228,7 @@ describe Puppet::Node::Ldap do
 
           node_indirection.expects(:name2hash).with('parent').returns nil
 
-          proc { node_indirection.find(request) }.should raise_error(Puppet::Error, /Could not find parent node/)
+          expect { node_indirection.find(request) }.to raise_error(Puppet::Error, /Could not find parent node/)
         end
 
         it "should add any parent classes to the node's classes" do
@@ -237,7 +237,7 @@ describe Puppet::Node::Ldap do
 
           @parent[:classes] = %w{c d}
 
-          node_indirection.find(request).classes.should == %w{a b c d}
+          expect(node_indirection.find(request).classes).to eq(%w{a b c d})
         end
 
         it "should add any parent parameters to the node's parameters" do
@@ -246,7 +246,7 @@ describe Puppet::Node::Ldap do
 
           @parent[:parameters]["three"] = "four"
 
-          node_indirection.find(request).parameters.should include({"one" => "two", "three" => "four"})
+          expect(node_indirection.find(request).parameters).to include({"one" => "two", "three" => "four"})
         end
 
         it "should prefer node parameters over parent parameters" do
@@ -255,7 +255,7 @@ describe Puppet::Node::Ldap do
 
           @parent[:parameters]["one"] = "three"
 
-          node_indirection.find(request).parameters.should include({"one" => "two"})
+          expect(node_indirection.find(request).parameters).to include({"one" => "two"})
         end
 
         it "should use the parent's environment if the node has none" do
@@ -267,7 +267,7 @@ describe Puppet::Node::Ldap do
           Puppet::Node::Facts.indirection.stubs(:find).with(nodename, :environment => env).returns(facts)
 
           Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
-            node_indirection.find(request).environment.should == env
+            expect(node_indirection.find(request).environment).to eq(env)
           end
         end
 
@@ -282,7 +282,7 @@ describe Puppet::Node::Ldap do
 
           Puppet.override(:environments => Puppet::Environments::Static.new(child_env)) do
 
-            node_indirection.find(request).environment.should == child_env
+            expect(node_indirection.find(request).environment).to eq(child_env)
           end
         end
 
@@ -295,13 +295,13 @@ describe Puppet::Node::Ldap do
 
           @parent_parent[:parameters]["five"] = "six"
 
-          node_indirection.find(request).parameters.should include("one" => "two", "three" => "four", "five" => "six")
+          expect(node_indirection.find(request).parameters).to include("one" => "two", "three" => "four", "five" => "six")
         end
 
         it "should not allow loops in parent declarations" do
           @entry[:parent] = "parent"
           @parent[:parent] = nodename
-          proc { node_indirection.find(request) }.should raise_error(ArgumentError)
+          expect { node_indirection.find(request) }.to raise_error(ArgumentError)
         end
       end
     end
@@ -350,14 +350,14 @@ describe Puppet::Node::Ldap do
       node_indirection.expects(:ldapsearch).yields("whatever")
       node_indirection.expects(:entry2hash).with("whatever",nil).returns(:name => nodename)
       result = node_indirection.search(request)
-      result[0].should be_instance_of(Puppet::Node)
-      result[0].name.should == nodename
+      expect(result[0]).to be_instance_of(Puppet::Node)
+      expect(result[0].name).to eq(nodename)
     end
 
     it "should merge each node's facts" do
       node_indirection.stubs(:ldapsearch).yields("one")
       node_indirection.stubs(:entry2hash).with("one",nil).returns(:name => nodename)
-      node_indirection.search(request)[0].parameters.should include(fact_values)
+      expect(node_indirection.search(request)[0].parameters).to include(fact_values)
     end
 
     it "should pass the request's fqdn option to entry2hash" do
@@ -371,27 +371,27 @@ describe Puppet::Node::Ldap do
   describe Puppet::Node::Ldap, " when developing the search query" do
     it "should return the value of the :ldapclassattrs split on commas as the class attributes" do
       Puppet[:ldapclassattrs] = "one,two"
-      node_indirection.class_attributes.should == %w{one two}
+      expect(node_indirection.class_attributes).to eq(%w{one two})
     end
 
     it "should return nil as the parent attribute if the :ldapparentattr is set to an empty string" do
       Puppet[:ldapparentattr] = ""
-      node_indirection.parent_attribute.should be_nil
+      expect(node_indirection.parent_attribute).to be_nil
     end
 
     it "should return the value of the :ldapparentattr as the parent attribute" do
       Puppet[:ldapparentattr] = "pere"
-      node_indirection.parent_attribute.should == "pere"
+      expect(node_indirection.parent_attribute).to eq("pere")
     end
 
     it "should use the value of the :ldapstring as the search filter" do
       Puppet[:ldapstring] = "mystring"
-      node_indirection.search_filter("testing").should == "mystring"
+      expect(node_indirection.search_filter("testing")).to eq("mystring")
     end
 
     it "should replace '%s' with the node name in the search filter if it is present" do
       Puppet[:ldapstring] = "my%sstring"
-      node_indirection.search_filter("testing").should == "mytestingstring"
+      expect(node_indirection.search_filter("testing")).to eq("mytestingstring")
     end
 
     it "should not modify the global :ldapstring when replacing '%s' in the search filter" do
@@ -399,21 +399,21 @@ describe Puppet::Node::Ldap do
       filter.expects(:include?).with("%s").returns(true)
       filter.expects(:gsub).with("%s", "testing").returns("mynewstring")
       Puppet[:ldapstring] = filter
-      node_indirection.search_filter("testing").should == "mynewstring"
+      expect(node_indirection.search_filter("testing")).to eq("mynewstring")
     end
   end
 
   describe Puppet::Node::Ldap, " when deciding attributes to search for" do
     it "should use 'nil' if the :ldapattrs setting is 'all'" do
       Puppet[:ldapattrs] = "all"
-      node_indirection.search_attributes.should be_nil
+      expect(node_indirection.search_attributes).to be_nil
     end
 
     it "should split the value of :ldapattrs on commas and use the result as the attribute list" do
       Puppet[:ldapattrs] = "one,two"
       node_indirection.stubs(:class_attributes).returns([])
       node_indirection.stubs(:parent_attribute).returns(nil)
-      node_indirection.search_attributes.should == %w{one two}
+      expect(node_indirection.search_attributes).to eq(%w{one two})
     end
 
     it "should add the class attributes to the search attributes if not returning all attributes" do
@@ -421,21 +421,21 @@ describe Puppet::Node::Ldap do
       node_indirection.stubs(:class_attributes).returns(%w{three four})
       node_indirection.stubs(:parent_attribute).returns(nil)
       # Sort them so i don't have to care about return order
-      node_indirection.search_attributes.sort.should == %w{one two three four}.sort
+      expect(node_indirection.search_attributes.sort).to eq(%w{one two three four}.sort)
     end
 
     it "should add the parent attribute to the search attributes if not returning all attributes" do
       Puppet[:ldapattrs] = "one,two"
       node_indirection.stubs(:class_attributes).returns([])
       node_indirection.stubs(:parent_attribute).returns("parent")
-      node_indirection.search_attributes.sort.should == %w{one two parent}.sort
+      expect(node_indirection.search_attributes.sort).to eq(%w{one two parent}.sort)
     end
 
     it "should not add nil parent attributes to the search attributes" do
       Puppet[:ldapattrs] = "one,two"
       node_indirection.stubs(:class_attributes).returns([])
       node_indirection.stubs(:parent_attribute).returns(nil)
-      node_indirection.search_attributes.should == %w{one two}
+      expect(node_indirection.search_attributes).to eq(%w{one two})
     end
   end
 end

data/spec/unit/indirector/node/msgpack_spec.rb

@@ -6,19 +6,19 @@ require 'puppet/indirector/node/msgpack'
 
 describe Puppet::Node::Msgpack, :if => Puppet.features.msgpack? do
   it "should be a subclass of the Msgpack terminus" do
-    Puppet::Node::Msgpack.superclass.should equal(Puppet::Indirector::Msgpack)
+    expect(Puppet::Node::Msgpack.superclass).to equal(Puppet::Indirector::Msgpack)
   end
 
   it "should have documentation" do
-    Puppet::Node::Msgpack.doc.should_not be_nil
+    expect(Puppet::Node::Msgpack.doc).not_to be_nil
   end
 
   it "should be registered with the configuration store indirection" do
     indirection = Puppet::Indirector::Indirection.instance(:node)
-    Puppet::Node::Msgpack.indirection.should equal(indirection)
+    expect(Puppet::Node::Msgpack.indirection).to equal(indirection)
   end
 
   it "should have its name set to :msgpack" do
-    Puppet::Node::Msgpack.name.should == :msgpack
+    expect(Puppet::Node::Msgpack.name).to eq(:msgpack)
   end
 end