puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/resource/status_spec.rb

@@ -14,105 +14,79 @@ describe Puppet::Resource::Status do
   end
 
   it "should compute type and title correctly" do
-    @status.resource_type.should == "File"
-    @status.title.should == make_absolute("/my/file")
+    expect(@status.resource_type).to eq("File")
+    expect(@status.title).to eq(make_absolute("/my/file"))
   end
 
-  [:node, :file, :line, :current_values, :status, :evaluation_time].each do |attr|
+  [:file, :line, :evaluation_time].each do |attr|
     it "should support #{attr}" do
       @status.send(attr.to_s + "=", "foo")
-      @status.send(attr).should == "foo"
+      expect(@status.send(attr)).to eq("foo")
     end
   end
 
   [:skipped, :failed, :restarted, :failed_to_restart, :changed, :out_of_sync, :scheduled].each do |attr|
     it "should support #{attr}" do
       @status.send(attr.to_s + "=", "foo")
-      @status.send(attr).should == "foo"
+      expect(@status.send(attr)).to eq("foo")
     end
 
     it "should have a boolean method for determining whehter it was #{attr}" do
       @status.send(attr.to_s + "=", "foo")
-      @status.should send("be_#{attr}")
+      expect(@status).to send("be_#{attr}")
     end
   end
 
   it "should accept a resource at initialization" do
-    Puppet::Resource::Status.new(@resource).resource.should_not be_nil
+    expect(Puppet::Resource::Status.new(@resource).resource).not_to be_nil
   end
 
   it "should set its source description to the resource's path" do
     @resource.expects(:path).returns "/my/path"
-    Puppet::Resource::Status.new(@resource).source_description.should == "/my/path"
+    expect(Puppet::Resource::Status.new(@resource).source_description).to eq("/my/path")
   end
 
   it "should set its containment path" do
-    Puppet::Resource::Status.new(@resource).containment_path.should == @containment_path
+    expect(Puppet::Resource::Status.new(@resource).containment_path).to eq(@containment_path)
   end
 
   [:file, :line].each do |attr|
     it "should copy the resource's #{attr}" do
       @resource.expects(attr).returns "foo"
-      Puppet::Resource::Status.new(@resource).send(attr).should == "foo"
+      expect(Puppet::Resource::Status.new(@resource).send(attr)).to eq("foo")
     end
   end
 
   it "should copy the resource's tags" do
     @resource.expects(:tags).returns %w{foo bar}
     status = Puppet::Resource::Status.new(@resource)
-    status.should be_tagged("foo")
-    status.should be_tagged("bar")
+    expect(status).to be_tagged("foo")
+    expect(status).to be_tagged("bar")
   end
 
   it "should always convert the resource to a string" do
     @resource.expects(:to_s).returns "foo"
-    Puppet::Resource::Status.new(@resource).resource.should == "foo"
+    expect(Puppet::Resource::Status.new(@resource).resource).to eq("foo")
   end
 
   it "should support tags" do
-    Puppet::Resource::Status.ancestors.should include(Puppet::Util::Tagging)
+    expect(Puppet::Resource::Status.ancestors).to include(Puppet::Util::Tagging)
   end
 
   it "should create a timestamp at its creation time" do
-    @status.time.should be_instance_of(Time)
-  end
-
-  describe "when sending logs" do
-    before do
-      Puppet::Util::Log.stubs(:new)
-    end
-
-    it "should set the tags to the event tags" do
-      Puppet::Util::Log.expects(:new).with { |args| args[:tags] == %w{one two} }
-      @status.stubs(:tags).returns %w{one two}
-      @status.send_log :notice, "my message"
-    end
-
-    [:file, :line].each do |attr|
-      it "should pass the #{attr}" do
-        Puppet::Util::Log.expects(:new).with { |args| args[attr] == "my val" }
-        @status.send(attr.to_s + "=", "my val")
-        @status.send_log :notice, "my message"
-      end
-    end
-
-    it "should use the source description as the source" do
-      Puppet::Util::Log.expects(:new).with { |args| args[:source] == "my source" }
-      @status.stubs(:source_description).returns "my source"
-      @status.send_log :notice, "my message"
-    end
+    expect(@status.time).to be_instance_of(Time)
   end
 
   it "should support adding events" do
     event = Puppet::Transaction::Event.new(:name => :foobar)
     @status.add_event(event)
-    @status.events.should == [event]
+    expect(@status.events).to eq([event])
   end
 
   it "should use '<<' to add events" do
     event = Puppet::Transaction::Event.new(:name => :foobar)
-    (@status << event).should equal(@status)
-    @status.events.should == [event]
+    expect(@status << event).to equal(@status)
+    expect(@status.events).to eq([event])
   end
 
   it "records an event for a failure caused by an error" do
@@ -125,36 +99,36 @@ describe Puppet::Resource::Status do
 
   it "should count the number of successful events and set changed" do
     3.times{ @status << Puppet::Transaction::Event.new(:status => 'success') }
-    @status.change_count.should == 3
+    expect(@status.change_count).to eq(3)
 
-    @status.changed.should == true
-    @status.out_of_sync.should == true
+    expect(@status.changed).to eq(true)
+    expect(@status.out_of_sync).to eq(true)
   end
 
   it "should not start with any changes" do
-    @status.change_count.should == 0
+    expect(@status.change_count).to eq(0)
 
-    @status.changed.should == false
-    @status.out_of_sync.should == false
+    expect(@status.changed).to eq(false)
+    expect(@status.out_of_sync).to eq(false)
   end
 
   it "should not treat failure, audit, or noop events as changed" do
     ['failure', 'audit', 'noop'].each do |s| @status << Puppet::Transaction::Event.new(:status => s) end
-    @status.change_count.should == 0
-    @status.changed.should == false
+    expect(@status.change_count).to eq(0)
+    expect(@status.changed).to eq(false)
   end
 
   it "should not treat audit events as out of sync" do
     @status << Puppet::Transaction::Event.new(:status => 'audit')
-    @status.out_of_sync_count.should == 0
-    @status.out_of_sync.should == false
+    expect(@status.out_of_sync_count).to eq(0)
+    expect(@status.out_of_sync).to eq(false)
   end
 
   ['failure', 'noop', 'success'].each do |event_status|
     it "should treat #{event_status} events as out of sync" do
       3.times do @status << Puppet::Transaction::Event.new(:status => event_status) end
-      @status.out_of_sync_count.should == 3
-      @status.out_of_sync.should == true
+      expect(@status.out_of_sync_count).to eq(3)
+      expect(@status.out_of_sync).to eq(true)
     end
   end
 
@@ -164,7 +138,7 @@ describe Puppet::Resource::Status do
       @status.line = 27
       @status.evaluation_time = 2.7
       @status.tags = %w{one two}
-      @status.to_yaml_properties.should =~ Puppet::Resource::Status::YAML_ATTRIBUTES
+      expect(@status.to_yaml_properties).to match_array(Puppet::Resource::Status::YAML_ATTRIBUTES)
     end
   end
 
@@ -179,27 +153,27 @@ describe Puppet::Resource::Status do
     @status.out_of_sync = true
     @status.skipped = false
 
-    @status.containment_path.should == @containment_path
+    expect(@status.containment_path).to eq(@containment_path)
 
     tripped = Puppet::Resource::Status.from_data_hash(PSON.parse(@status.to_pson))
 
-    tripped.title.should == @status.title
-    tripped.containment_path.should == @status.containment_path
-    tripped.file.should == @status.file
-    tripped.line.should == @status.line
-    tripped.resource.should == @status.resource
-    tripped.resource_type.should == @status.resource_type
-    tripped.evaluation_time.should == @status.evaluation_time
-    tripped.tags.should == @status.tags
-    tripped.time.should == @status.time
-    tripped.failed.should == @status.failed
-    tripped.changed.should == @status.changed
-    tripped.out_of_sync.should == @status.out_of_sync
-    tripped.skipped.should == @status.skipped
-
-    tripped.change_count.should == @status.change_count
-    tripped.out_of_sync_count.should == @status.out_of_sync_count
-    events_as_hashes(tripped).should == events_as_hashes(@status)
+    expect(tripped.title).to eq(@status.title)
+    expect(tripped.containment_path).to eq(@status.containment_path)
+    expect(tripped.file).to eq(@status.file)
+    expect(tripped.line).to eq(@status.line)
+    expect(tripped.resource).to eq(@status.resource)
+    expect(tripped.resource_type).to eq(@status.resource_type)
+    expect(tripped.evaluation_time).to eq(@status.evaluation_time)
+    expect(tripped.tags).to eq(@status.tags)
+    expect(tripped.time).to eq(@status.time)
+    expect(tripped.failed).to eq(@status.failed)
+    expect(tripped.changed).to eq(@status.changed)
+    expect(tripped.out_of_sync).to eq(@status.out_of_sync)
+    expect(tripped.skipped).to eq(@status.skipped)
+
+    expect(tripped.change_count).to eq(@status.change_count)
+    expect(tripped.out_of_sync_count).to eq(@status.out_of_sync_count)
+    expect(events_as_hashes(tripped)).to eq(events_as_hashes(@status))
   end
 
   def events_as_hashes(report)

data/spec/unit/resource/type_collection_helper_spec.rb

@@ -19,6 +19,6 @@ describe Puppet::Resource::TypeCollectionHelper do
     rtc = stub 'known_resource_types'
     env.expects(:known_resource_types).returns  rtc
 
-    @helper.known_resource_types.should equal(rtc)
+    expect(@helper.known_resource_types).to equal(rtc)
   end
 end

data/spec/unit/resource/type_collection_spec.rb

@@ -24,16 +24,16 @@ describe Puppet::Resource::TypeCollection do
     node = Puppet::Resource::Type.new(:node, "foo")
 
     @code.add(node)
-    @code.node("foo").should equal(node)
+    expect(@code.node("foo")).to equal(node)
 
-    node.resource_type_collection.should equal(@code)
+    expect(node.resource_type_collection).to equal(@code)
   end
 
   it "should store node resource types as nodes" do
     node = Puppet::Resource::Type.new(:node, "foo")
 
     @code.add(node)
-    @code.node("foo").should equal(node)
+    expect(@code.node("foo")).to equal(node)
   end
 
   it "should fail if a duplicate node is added" do
@@ -48,7 +48,7 @@ describe Puppet::Resource::TypeCollection do
     klass = Puppet::Resource::Type.new(:hostclass, "foo")
 
     @code.add(klass)
-    @code.hostclass("foo").should equal(klass)
+    expect(@code.hostclass("foo")).to equal(klass)
   end
 
   it "merge together hostclasses of the same name" do
@@ -58,14 +58,14 @@ describe Puppet::Resource::TypeCollection do
     @code.add(klass1)
     @code.add(klass2)
 
-    @code.hostclass("foo").doc.should == "firstsecond"
+    expect(@code.hostclass("foo").doc).to eq("firstsecond")
   end
 
   it "should store definitions as definitions" do
     define = Puppet::Resource::Type.new(:definition, "foo")
 
     @code.add(define)
-    @code.definition("foo").should equal(define)
+    expect(@code.definition("foo")).to equal(define)
   end
 
   it "should fail if a duplicate definition is added" do
@@ -81,42 +81,11 @@ describe Puppet::Resource::TypeCollection do
     loader.add Puppet::Resource::Type.new(:hostclass, "class")
     loader.add Puppet::Resource::Type.new(:definition, "define")
     loader.add Puppet::Resource::Type.new(:node, "node")
-    watched_file = tmpfile('watched_file')
-    loader.watch_file(watched_file)
 
     loader.clear
-    loader.hostclass("class").should be_nil
-    loader.definition("define").should be_nil
-    loader.node("node").should be_nil
-    loader.should_not be_watching_file(watched_file)
-  end
-
-  describe "when resolving namespaces" do
-    [ ['',               '::foo', ['foo']],
-      ['a',              '::foo', ['foo']],
-      ['a::b',           '::foo', ['foo']],
-      [['a::b'],         '::foo', ['foo']],
-      [['a::b', 'c'],    '::foo', ['foo']],
-      [['A::B', 'C'],    '::Foo', ['foo']],
-      ['',               '',      ['']],
-      ['a',              '',      ['']],
-      ['a::b',           '',      ['']],
-      [['a::b'],         '',      ['']],
-      [['a::b', 'c'],    '',      ['']],
-      [['A::B', 'C'],    '',      ['']],
-      ['',               'foo',   ['foo']],
-      ['a',              'foo',   ['a::foo', 'foo']],
-      ['a::b',           'foo',   ['a::b::foo', 'a::foo', 'foo']],
-      ['A::B',           'Foo',   ['a::b::foo', 'a::foo', 'foo']],
-      [['a::b'],         'foo',   ['a::b::foo', 'a::foo', 'foo']],
-      [['a', 'b'],       'foo',   ['a::foo', 'foo', 'b::foo']],
-      [['a::b', 'c::d'], 'foo',   ['a::b::foo', 'a::foo', 'foo', 'c::d::foo', 'c::foo']],
-      [['a::b', 'a::c'], 'foo',   ['a::b::foo', 'a::foo', 'foo', 'a::c::foo']],
-    ].each do |namespaces, name, expected_result|
-      it "should resolve #{name.inspect} in namespaces #{namespaces.inspect} correctly" do
-        @code.instance_eval { resolve_namespaces(namespaces, name) }.should == expected_result
-      end
-    end
+    expect(loader.hostclass("class")).to be_nil
+    expect(loader.definition("define")).to be_nil
+    expect(loader.node("node")).to be_nil
   end
 
   describe "when looking up names" do
@@ -124,55 +93,62 @@ describe Puppet::Resource::TypeCollection do
       @type = Puppet::Resource::Type.new(:hostclass, "ns::klass")
     end
 
-    it "should support looking up with multiple namespaces" do
-      @code.add @type
-      @code.find_hostclass(%w{boo baz ns}, "klass").should equal(@type)
-    end
-
     it "should not attempt to import anything when the type is already defined" do
       @code.add @type
       @code.loader.expects(:import).never
-      @code.find_hostclass(%w{ns}, "klass").should equal(@type)
+      expect(@code.find_hostclass("ns::klass")).to equal(@type)
     end
 
     describe "that need to be loaded" do
       it "should use the loader to load the files" do
-        @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass")
         @code.loader.expects(:try_load_fqname).with(:hostclass, "klass")
-        @code.find_hostclass(["ns"], "klass")
+        @code.find_hostclass("klass")
+      end
+      it "should use the loader to load the files" do
+        @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass")
+        @code.find_hostclass("ns::klass")
       end
 
       it "should downcase the name and downcase and array-fy the namespaces before passing to the loader" do
         @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass")
-        @code.loader.expects(:try_load_fqname).with(:hostclass, "klass")
-        @code.find_hostclass("Ns", "Klass")
+        @code.find_hostclass("ns::klass")
       end
 
       it "should use the class returned by the loader" do
         @code.loader.expects(:try_load_fqname).returns(:klass)
         @code.expects(:hostclass).with("ns::klass").returns(false)
-        @code.find_hostclass("ns", "klass").should == :klass
+        expect(@code.find_hostclass("ns::klass")).to eq(:klass)
       end
 
       it "should return nil if the name isn't found" do
         @code.loader.stubs(:try_load_fqname).returns(nil)
-        @code.find_hostclass("Ns", "Klass").should be_nil
+        expect(@code.find_hostclass("Ns::Klass")).to be_nil
       end
 
       it "already-loaded names at broader scopes should not shadow autoloaded names" do
         @code.add Puppet::Resource::Type.new(:hostclass, "bar")
         @code.loader.expects(:try_load_fqname).with(:hostclass, "foo::bar").returns(:foobar)
-        @code.find_hostclass("foo", "bar").should == :foobar
+        expect(@code.find_hostclass("foo::bar")).to eq(:foobar)
       end
 
-      it "should not try to autoload names that we couldn't autoload in a previous step if ignoremissingtypes is enabled" do
-        Puppet[:ignoremissingtypes] = true
-        @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass").returns(nil)
-        @code.loader.expects(:try_load_fqname).with(:hostclass, "klass").returns(nil)
-        @code.find_hostclass("Ns", "Klass").should be_nil
+      context 'when debugging' do
+        # This test requires that debugging is on, it will otherwise not make a call to debug,
+        # which is the easiest way to detect that that a certain path has been taken.
+        before(:each) do
+          Puppet.debug = true
+        end
+
+        after (:each) do
+          Puppet.debug = false
+        end
 
-        Puppet.expects(:debug).at_least_once.with {|msg| msg =~ /Not attempting to load hostclass/}
-        @code.find_hostclass("Ns", "Klass").should be_nil
+        it "should not try to autoload names that we couldn't autoload in a previous step if ignoremissingtypes is enabled" do
+          Puppet[:ignoremissingtypes] = true
+          @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass").returns(nil)
+          expect(@code.find_hostclass("ns::klass")).to be_nil
+          Puppet.expects(:debug).at_least_once.with {|msg| msg =~ /Not attempting to load hostclass/}
+          expect(@code.find_hostclass("ns::klass")).to be_nil
+        end
       end
     end
   end
@@ -184,7 +160,7 @@ describe Puppet::Resource::TypeCollection do
         loader = Puppet::Resource::TypeCollection.new(environment)
         instance = Puppet::Resource::Type.new(data, "foo")
 
-        loader.add(instance).should equal(instance)
+        expect(loader.add(instance)).to equal(instance)
       end
 
       it "should retrieve #{data} insensitive to case" do
@@ -193,11 +169,11 @@ describe Puppet::Resource::TypeCollection do
 
         loader.add instance
 
-        loader.send(data, "bAr").should equal(instance)
+        expect(loader.send(data, "bAr")).to equal(instance)
       end
 
       it "should return nil when asked for a #{data} that has not been added" do
-        Puppet::Resource::TypeCollection.new(environment).send(data, "foo").should be_nil
+        expect(Puppet::Resource::TypeCollection.new(environment).send(data, "foo")).to be_nil
       end
     end
   end
@@ -207,68 +183,33 @@ describe Puppet::Resource::TypeCollection do
       loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
-      loader.find_hostclass("namespace", "::foo::bar").should equal(instance)
+      expect(loader.find_hostclass("::foo::bar")).to equal(instance)
     end
 
     it "should return nil if the instance name is fully qualified and no such instance exists" do
       loader = Puppet::Resource::TypeCollection.new(environment)
-      loader.find_hostclass("namespace", "::foo::bar").should be_nil
+      expect(loader.find_hostclass("::foo::bar")).to be_nil
     end
 
     it "should be able to find classes in the base namespace" do
       loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo")
       loader.add instance
-      loader.find_hostclass("", "foo").should equal(instance)
-    end
-
-    it "should return the partially qualified object if it exists in a provided namespace" do
-      loader = Puppet::Resource::TypeCollection.new(environment)
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
-      loader.add instance
-      loader.find_hostclass("foo", "bar::baz").should equal(instance)
-    end
-
-    it "should be able to find partially qualified objects in any of the provided namespaces" do
-      loader = Puppet::Resource::TypeCollection.new(environment)
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
-      loader.add instance
-      loader.find_hostclass(["nons", "foo", "otherns"], "bar::baz").should equal(instance)
+      expect(loader.find_hostclass("foo")).to equal(instance)
     end
 
     it "should return the unqualified object if it exists in a provided namespace" do
       loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
-      loader.find_hostclass("foo", "bar").should equal(instance)
-    end
-
-    it "should return the unqualified object if it exists in the parent namespace" do
-      loader = Puppet::Resource::TypeCollection.new(environment)
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
-      loader.add instance
-      loader.find_hostclass("foo::bar::baz", "bar").should equal(instance)
-    end
-
-    it "should should return the partially qualified object if it exists in the parent namespace" do
-      loader = Puppet::Resource::TypeCollection.new(environment)
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
-      loader.add instance
-      loader.find_hostclass("foo::bar", "bar::baz").should equal(instance)
-    end
-
-    it "should return the qualified object if it exists in the root namespace" do
-      loader = Puppet::Resource::TypeCollection.new(environment)
-      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
-      loader.add instance
-      loader.find_hostclass("foo::bar", "foo::bar::baz").should equal(instance)
+      expect(loader.find_hostclass("foo::bar")).to equal(instance)
     end
 
     it "should return nil if the object cannot be found" do
       loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
-      loader.find_hostclass("foo::bar", "eh").should be_nil
+      expect(loader.find_hostclass("foo::bar::eh")).to be_nil
     end
 
     describe "when topscope has a class that has the same name as a local class" do
@@ -279,16 +220,11 @@ describe Puppet::Resource::TypeCollection do
         end
       end
 
-      it "should favor the local class, if the name is unqualified" do
-        @loader.find_hostclass("foo", "bar").name.should == 'foo::bar'
-      end
-
-      it "should only look in the topclass, if the name is qualified" do
-        @loader.find_hostclass("foo", "::bar").name.should == 'bar'
-      end
-
-      it "should only look in the topclass, if we assume the name is fully qualified" do
-        @loader.find_hostclass("foo", "bar", :assume_fqname => true).name.should == 'bar'
+      it "looks up the given name, no more, no less" do
+        expect(@loader.find_hostclass("bar").name).to eq('bar')
+        expect(@loader.find_hostclass("::bar").name).to eq('bar')
+        expect(@loader.find_hostclass("foo::bar").name).to eq('foo::bar')
+        expect(@loader.find_hostclass("::foo::bar").name).to eq('foo::bar')
       end
     end
 
@@ -296,7 +232,7 @@ describe Puppet::Resource::TypeCollection do
         @loader = Puppet::Resource::TypeCollection.new(environment)
         @loader.add Puppet::Resource::Type.new(:hostclass, "foo::bar")
 
-        @loader.find_hostclass("foo", "::bar").should == nil
+        expect(@loader.find_hostclass("::bar")).to eq(nil)
     end
 
   end
@@ -305,17 +241,17 @@ describe Puppet::Resource::TypeCollection do
     node = Puppet::Resource::Type.new(:node, "bar")
     loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add(node)
-    loader.find_node(stub("ignored"), "bar").should == node
+    expect(loader.find_node("bar")).to eq(node)
   end
 
   it "should indicate whether any nodes are defined" do
     loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add_node(Puppet::Resource::Type.new(:node, "foo"))
-    loader.should be_nodes
+    expect(loader).to be_nodes
   end
 
   it "should indicate whether no nodes are defined" do
-    Puppet::Resource::TypeCollection.new(environment).should_not be_nodes
+    expect(Puppet::Resource::TypeCollection.new(environment)).not_to be_nodes
   end
 
   describe "when finding nodes" do
@@ -327,7 +263,7 @@ describe Puppet::Resource::TypeCollection do
       node = Puppet::Resource::Type.new(:node, "foo")
       @loader << node
 
-      @loader.node("foo").should equal(node)
+      expect(@loader.node("foo")).to equal(node)
     end
 
     it "should return the first regex node whose regex matches the provided node name" do
@@ -335,7 +271,7 @@ describe Puppet::Resource::TypeCollection do
       node2 = Puppet::Resource::Type.new(:node, /\d/)
       @loader << node1 << node2
 
-      @loader.node("foo10").should equal(node1)
+      expect(@loader.node("foo10")).to equal(node1)
     end
 
     it "should preferentially return a node whose name is string-equal over returning a node whose regex matches a provided name" do
@@ -343,48 +279,7 @@ describe Puppet::Resource::TypeCollection do
       node2 = Puppet::Resource::Type.new(:node, "foo")
       @loader << node1 << node2
 
-      @loader.node("foo").should equal(node2)
-    end
-  end
-
-  describe "when managing files" do
-    before do
-      @loader = Puppet::Resource::TypeCollection.new(environment)
-      Puppet::Util::WatchedFile.stubs(:new).returns stub("watched_file")
-    end
-
-    it "should have a method for specifying a file should be watched" do
-      @loader.should respond_to(:watch_file)
-    end
-
-    it "should have a method for determining if a file is being watched" do
-      @loader.watch_file("/foo/bar")
-      @loader.should be_watching_file("/foo/bar")
-    end
-
-    it "should use WatchedFile to watch files" do
-      Puppet::Util::WatchedFile.expects(:new).with("/foo/bar").returns stub("watched_file")
-      @loader.watch_file("/foo/bar")
-    end
-
-    it "should be considered stale if any files have changed" do
-      file1 = stub 'file1', :changed? => false
-      file2 = stub 'file2', :changed? => true
-      Puppet::Util::WatchedFile.expects(:new).times(2).returns(file1).then.returns(file2)
-      @loader.watch_file("/foo/bar")
-      @loader.watch_file("/other/bar")
-
-      @loader.should be_stale
-    end
-
-    it "should not be considered stable if no files have changed" do
-      file1 = stub 'file1', :changed? => false
-      file2 = stub 'file2', :changed? => false
-      Puppet::Util::WatchedFile.expects(:new).times(2).returns(file1).then.returns(file2)
-      @loader.watch_file("/foo/bar")
-      @loader.watch_file("/other/bar")
-
-      @loader.should_not be_stale
+      expect(@loader.node("foo")).to equal(node2)
     end
   end
 
@@ -397,7 +292,7 @@ describe Puppet::Resource::TypeCollection do
       time = Time.now
 
       Time.stubs(:now).returns time
-      @code.version.should == time.to_i
+      expect(@code.version).to eq(time.to_i)
     end
 
     context "when config_version script is specified" do
@@ -405,13 +300,13 @@ describe Puppet::Resource::TypeCollection do
 
       it "should use the output of the environment's config_version setting if one is provided" do
         Puppet::Util::Execution.expects(:execute).with(["/my/foo"]).returns "output\n"
-        @code.version.should == "output"
+        expect(@code.version).to eq("output")
       end
 
       it "should raise a puppet parser error if executing config_version fails" do
         Puppet::Util::Execution.expects(:execute).raises(Puppet::ExecutionFailure.new("msg"))
 
-        lambda { @code.version }.should raise_error(Puppet::ParseError)
+        expect { @code.version }.to raise_error(Puppet::ParseError)
       end
     end
   end