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

data/spec/unit/node/facts_spec.rb

@@ -1,4 +1,5 @@
 #! /usr/bin/env ruby
+
 require 'spec_helper'
 require 'puppet/node/facts'
 require 'matchers/json'
@@ -10,37 +11,31 @@ describe Puppet::Node::Facts, "when indirecting" do
     @facts = Puppet::Node::Facts.new("me")
   end
 
-  it "should be able to convert all fact values to strings" do
-    @facts.values["one"] = 1
-    @facts.stringify
-    @facts.values["one"].should == "1"
-  end
-
   describe "adding local facts" do
     it "should add the node's certificate name as the 'clientcert' fact" do
       @facts.add_local_facts
-      @facts.values["clientcert"].should == Puppet.settings[:certname]
+      expect(@facts.values["clientcert"]).to eq(Puppet.settings[:certname])
     end
 
     it "adds the Puppet version as a 'clientversion' fact" do
       @facts.add_local_facts
-      @facts.values["clientversion"].should == Puppet.version.to_s
+      expect(@facts.values["clientversion"]).to eq(Puppet.version.to_s)
     end
 
     it "adds the agent side noop setting as 'clientnoop'" do
       @facts.add_local_facts
-      @facts.values["clientnoop"].should == Puppet.settings[:noop]
+      expect(@facts.values["clientnoop"]).to eq(Puppet.settings[:noop])
     end
 
     it "doesn't add the current environment" do
       @facts.add_local_facts
-      @facts.values.should_not include("environment")
+      expect(@facts.values).not_to include("environment")
     end
 
     it "doesn't replace any existing environment fact when adding local facts" do
       @facts.values["environment"] = "foo"
       @facts.add_local_facts
-      @facts.values["environment"].should == "foo"
+      expect(@facts.values["environment"]).to eq("foo")
     end
   end
 
@@ -48,43 +43,43 @@ describe Puppet::Node::Facts, "when indirecting" do
     it "should convert fact values if needed" do
       @facts.values["test"] = /foo/
       @facts.sanitize
-      @facts.values["test"].should == "(?-mix:foo)"
+      expect(@facts.values["test"]).to eq("(?-mix:foo)")
     end
 
     it "should convert hash keys if needed" do
       @facts.values["test"] = {/foo/ => "bar"}
       @facts.sanitize
-      @facts.values["test"].should == {"(?-mix:foo)" => "bar"}
+      expect(@facts.values["test"]).to eq({"(?-mix:foo)" => "bar"})
     end
 
     it "should convert hash values if needed" do
       @facts.values["test"] = {"foo" => /bar/}
       @facts.sanitize
-      @facts.values["test"].should == {"foo" => "(?-mix:bar)"}
+      expect(@facts.values["test"]).to eq({"foo" => "(?-mix:bar)"})
     end
 
     it "should convert array elements if needed" do
       @facts.values["test"] = [1, "foo", /bar/]
       @facts.sanitize
-      @facts.values["test"].should == [1, "foo", "(?-mix:bar)"]
+      expect(@facts.values["test"]).to eq([1, "foo", "(?-mix:bar)"])
     end
 
     it "should handle nested arrays" do
       @facts.values["test"] = [1, "foo", [/bar/]]
       @facts.sanitize
-      @facts.values["test"].should == [1, "foo", ["(?-mix:bar)"]]
+      expect(@facts.values["test"]).to eq([1, "foo", ["(?-mix:bar)"]])
     end
 
     it "should handle nested hashes" do
       @facts.values["test"] = {/foo/ => {"bar" => /baz/}}
       @facts.sanitize
-      @facts.values["test"].should == {"(?-mix:foo)" => {"bar" => "(?-mix:baz)"}}
+      expect(@facts.values["test"]).to eq({"(?-mix:foo)" => {"bar" => "(?-mix:baz)"}})
     end
 
     it "should handle nester arrays and hashes" do
       @facts.values["test"] = {/foo/ => ["bar", /baz/]}
       @facts.sanitize
-      @facts.values["test"].should == {"(?-mix:foo)" => ["bar", "(?-mix:baz)"]}
+      expect(@facts.values["test"]).to eq({"(?-mix:foo)" => ["bar", "(?-mix:baz)"]})
     end
   end
 
@@ -104,23 +99,65 @@ describe Puppet::Node::Facts, "when indirecting" do
     describe "when the Puppet application is 'master'" do
       it "should default to the 'yaml' terminus" do
         pending "Cannot test the behavior of defaults in defaults.rb"
-        # Puppet::Node::Facts.indirection.terminus_class.should == :yaml
+        expect(Puppet::Node::Facts.indirection.terminus_class).to eq(:yaml)
       end
     end
 
     describe "when the Puppet application is not 'master'" do
       it "should default to the 'facter' terminus" do
         pending "Cannot test the behavior of defaults in defaults.rb"
-        # Puppet::Node::Facts.indirection.terminus_class.should == :facter
+        expect(Puppet::Node::Facts.indirection.terminus_class).to eq(:facter)
       end
     end
 
   end
 
   describe "when storing and retrieving" do
-    it "should add metadata to the facts" do
-      facts = Puppet::Node::Facts.new("me", "one" => "two", "three" => "four")
-      facts.values['_timestamp'].should be_instance_of(Time)
+    it "doesn't manufacture a `_timestamp` fact value" do
+      values = {"one" => "two", "three" => "four"}
+      facts = Puppet::Node::Facts.new("mynode", values)
+
+      expect(facts.values).to eq(values)
+    end
+
+    describe "when deserializing from yaml" do
+      let(:timestamp)  { Time.parse("Thu Oct 28 11:16:31 -0700 2010") }
+      let(:expiration) { Time.parse("Thu Oct 28 11:21:31 -0700 2010") }
+
+      def create_facts(values = {})
+        Puppet::Node::Facts.new('mynode', values)
+      end
+
+      def deserialize_yaml_facts(facts)
+        format = Puppet::Network::FormatHandler.format('yaml')
+        format.intern(Puppet::Node::Facts, facts.to_yaml)
+      end
+
+      it 'preserves `_timestamp` value' do
+        facts = deserialize_yaml_facts(create_facts('_timestamp' => timestamp))
+
+        expect(facts.timestamp).to eq(timestamp)
+      end
+
+      it "doesn't preserve the `_timestamp` fact" do
+        facts = deserialize_yaml_facts(create_facts('_timestamp' => timestamp))
+
+        expect(facts.values['_timestamp']).to be_nil
+      end
+
+      it 'preserves expiration time if present' do
+        old_facts = create_facts
+        old_facts.expiration = expiration
+        facts = deserialize_yaml_facts(old_facts)
+
+        expect(facts.expiration).to eq(expiration)
+      end
+
+      it 'ignores expiration time if absent' do
+        facts = deserialize_yaml_facts(create_facts)
+
+        expect(facts.expiration).to be_nil
+      end
     end
 
     describe "using pson" do
@@ -133,9 +170,10 @@ describe Puppet::Node::Facts, "when indirecting" do
         pson = %Q({"name": "foo", "expiration": "#{@expiration}", "timestamp": "#{@timestamp}", "values": {"a": "1", "b": "2", "c": "3"}})
         format = Puppet::Network::FormatHandler.format('pson')
         facts = format.intern(Puppet::Node::Facts,pson)
-        facts.name.should == 'foo'
-        facts.expiration.should == @expiration
-        facts.values.should == {'a' => '1', 'b' => '2', 'c' => '3', '_timestamp' => @timestamp}
+        expect(facts.name).to eq('foo')
+        expect(facts.expiration).to eq(@expiration)
+        expect(facts.timestamp).to eq(@timestamp)
+        expect(facts.values).to eq({'a' => '1', 'b' => '2', 'c' => '3'})
       end
 
       it "should generate properly formatted pson" do
@@ -143,10 +181,10 @@ describe Puppet::Node::Facts, "when indirecting" do
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
         facts.expiration = @expiration
         result = PSON.parse(facts.to_pson)
-        result['name'].should == facts.name
-        result['values'].should == facts.values.reject { |key, value| key.to_s =~ /_/ }
-        result['timestamp'].should == facts.timestamp.iso8601(9)
-        result['expiration'].should == facts.expiration.iso8601(9)
+        expect(result['name']).to eq(facts.name)
+        expect(result['values']).to eq(facts.values)
+        expect(result['timestamp']).to eq(facts.timestamp.iso8601(9))
+        expect(result['expiration']).to eq(facts.expiration.iso8601(9))
       end
 
       it "should generate valid facts data against the facts schema" do
@@ -160,15 +198,15 @@ describe Puppet::Node::Facts, "when indirecting" do
       it "should not include nil values" do
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
         pson = PSON.parse(facts.to_pson)
-        pson.should_not be_include("expiration")
+        expect(pson).not_to be_include("expiration")
       end
 
       it "should be able to handle nil values" do
         pson = %Q({"name": "foo", "values": {"a": "1", "b": "2", "c": "3"}})
         format = Puppet::Network::FormatHandler.format('pson')
         facts = format.intern(Puppet::Node::Facts,pson)
-        facts.name.should == 'foo'
-        facts.expiration.should be_nil
+        expect(facts.name).to eq('foo')
+        expect(facts.expiration).to be_nil
       end
     end
   end

data/spec/unit/node_spec.rb

@@ -8,100 +8,84 @@ describe Puppet::Node do
   let(:environment) { Puppet::Node::Environment.create(:bar, []) }
   let(:env_loader) { Puppet::Environments::Static.new(environment) }
 
-  it "should register its document type as Node" do
-    PSON.registered_document_types["Node"].should equal(Puppet::Node)
-  end
-
   describe "when managing its environment" do
-    it "should use any set environment" do
-      Puppet.override(:environments => env_loader) do
-        Puppet::Node.new("foo", :environment => "bar").environment.should == environment
-      end
-    end
 
-    it "should support providing an actual environment instance" do
-      Puppet::Node.new("foo", :environment => environment).environment.name.should == :bar
+    it "provides an environment instance" do
+      expect(Puppet::Node.new("foo", :environment => environment).environment.name).to eq(:bar)
     end
 
-    it "should determine its environment from its parameters if no environment is set" do
-      Puppet.override(:environments => env_loader) do
-        Puppet::Node.new("foo", :parameters => {"environment" => :bar}).environment.should == environment
+    context "present in a loader" do
+      around do |example|
+        Puppet.override(:environments => env_loader) do
+          example.run
+        end
       end
-    end
 
-    it "should use the configured environment if no environment is provided" do
-      Puppet[:environment] = environment.name.to_s
+      it "uses any set environment" do
+        expect(Puppet::Node.new("foo", :environment => "bar").environment).to eq(environment)
+      end
 
-      Puppet.override(:environments => env_loader) do
-        Puppet::Node.new("foo").environment.should == environment
+      it "determines its environment from its parameters if no environment is set" do
+        expect(Puppet::Node.new("foo", :parameters => {"environment" => :bar}).environment).to eq(environment)
       end
-    end
 
-    it "should allow the environment to be set after initialization" do
-      node = Puppet::Node.new("foo")
-      node.environment = :bar
-      node.environment.name.should == :bar
-    end
+      it "uses the configured environment if no environment is provided" do
+        Puppet[:environment] = environment.name.to_s
+        expect(Puppet::Node.new("foo").environment).to eq(environment)
+      end
 
-    it "should allow its environment to be set by parameters after initialization" do
-      node = Puppet::Node.new("foo")
-      node.parameters["environment"] = :bar
-      node.environment.name.should == :bar
-    end
+      it "allows the environment to be set after initialization" do
+        node = Puppet::Node.new("foo")
+        node.environment = :bar
+        expect(node.environment.name).to eq(:bar)
+      end
 
-    it "should allow its environment parameter to be set by attribute after initialization" do
-      node = Puppet::Node.new("foo", { :parameters => { 'environment' => :foo } })
-      node.environment_name = :foo
-      node.environment = :bar
-      expect(node.environment_name).to eq(:bar)
-      expect(node.parameters['environment']).to eq(:bar)
+      it "allows its environment to be set by parameters after initialization" do
+        node = Puppet::Node.new("foo")
+        node.parameters["environment"] = :bar
+        expect(node.environment.name).to eq(:bar)
+      end
     end
   end
 
-  it "can survive a round-trip through YAML" do
-    facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
-    node = Puppet::Node.new("hello",
-                            :environment => 'kjhgrg',
-                            :classes => ['erth', 'aiu'],
-                            :parameters => {"hostname"=>"food"}
-                           )
-    new_node = Puppet::Node.convert_from('yaml', node.render('yaml'))
-    new_node.environment.should == node.environment
-    new_node.parameters.should == node.parameters
-    new_node.classes.should == node.classes
-    new_node.name.should == node.name
-  end
+  describe "serialization" do
+    around do |example|
+      Puppet.override(:environments => env_loader) do
+        example.run
+      end
+    end
 
-  it "can round-trip through pson" do
-    facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
-    node = Puppet::Node.new("hello",
-                            :environment => 'kjhgrg',
-                            :classes => ['erth', 'aiu'],
-                            :parameters => {"hostname"=>"food"}
-                           )
-    new_node = Puppet::Node.convert_from('pson', node.render('pson'))
-    new_node.environment.should == node.environment
-    new_node.parameters.should == node.parameters
-    new_node.classes.should == node.classes
-    new_node.name.should == node.name
-  end
+    it "can round-trip through pson" do
+      facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
+      node = Puppet::Node.new("hello",
+                              :environment => 'bar',
+                              :classes => ['erth', 'aiu'],
+                              :parameters => {"hostname"=>"food"}
+                             )
+      new_node = Puppet::Node.convert_from('pson', node.render('pson'))
+      expect(new_node.environment).to eq(node.environment)
+      expect(new_node.parameters).to eq(node.parameters)
+      expect(new_node.classes).to eq(node.classes)
+      expect(new_node.name).to eq(node.name)
+    end
 
-  it "validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
-    facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
-    node = Puppet::Node.new("hello",
-                            :environment => 'kjhgrg',
-                            :classes => ['erth', 'aiu'],
-                            :parameters => {"hostname"=>"food"}
-                           )
-    expect(node.to_pson).to validate_against('api/schemas/node.json')
-  end
+    it "validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
+      facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
+      node = Puppet::Node.new("hello",
+                              :environment => 'bar',
+                              :classes => ['erth', 'aiu'],
+                              :parameters => {"hostname"=>"food"}
+                             )
+      expect(node.to_pson).to validate_against('api/schemas/node.json')
+    end
 
-  it "when missing optional parameters validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
-    facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
-    node = Puppet::Node.new("hello",
-                            :environment => 'kjhgrg'
-                           )
-    expect(node.to_pson).to validate_against('api/schemas/node.json')
+    it "when missing optional parameters validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
+      facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
+      node = Puppet::Node.new("hello",
+                              :environment => 'bar'
+                             )
+      expect(node.to_pson).to validate_against('api/schemas/node.json')
+    end
   end
 
   describe "when converting to json" do
@@ -109,35 +93,31 @@ describe Puppet::Node do
       @node = Puppet::Node.new("mynode")
     end
 
-    it "should provide its name" do
-      @node.should set_json_attribute('name').to("mynode")
-    end
-
-    it "should produce a hash with the document_type set to 'Node'" do
-      @node.should set_json_document_type_to("Node")
+    it "provide its name" do
+      expect(@node).to set_json_attribute('name').to("mynode")
     end
 
-    it "should include the classes if set" do
+    it "includes the classes if set" do
       @node.classes = %w{a b c}
-      @node.should set_json_attribute("classes").to(%w{a b c})
+      expect(@node).to set_json_attribute("classes").to(%w{a b c})
     end
 
-    it "should not include the classes if there are none" do
-      @node.should_not set_json_attribute('classes')
+    it "does not include the classes if there are none" do
+      expect(@node).to_not set_json_attribute('classes')
     end
 
-    it "should include parameters if set" do
+    it "includes parameters if set" do
       @node.parameters = {"a" => "b", "c" => "d"}
-      @node.should set_json_attribute('parameters').to({"a" => "b", "c" => "d"})
+      expect(@node).to set_json_attribute('parameters').to({"a" => "b", "c" => "d"})
     end
 
-    it "should not include the parameters if there are none" do
-      @node.should_not set_json_attribute('parameters')
+    it "does not include the parameters if there are none" do
+      expect(@node).to_not set_json_attribute('parameters')
     end
 
-    it "should include the environment" do
+    it "includes the environment" do
       @node.environment = "production"
-      @node.should set_json_attribute('environment').to('production')
+      expect(@node).to set_json_attribute('environment').to('production')
     end
   end
 
@@ -151,23 +131,23 @@ describe Puppet::Node do
       @format.intern(Puppet::Node, json)
     end
 
-    it "should set its name" do
-      Puppet::Node.should read_json_attribute('name').from(@node.to_pson).as("mynode")
+    it "sets its name" do
+      expect(Puppet::Node).to read_json_attribute('name').from(@node.to_pson).as("mynode")
     end
 
-    it "should include the classes if set" do
+    it "includes the classes if set" do
       @node.classes = %w{a b c}
-      Puppet::Node.should read_json_attribute('classes').from(@node.to_pson).as(%w{a b c})
+      expect(Puppet::Node).to read_json_attribute('classes').from(@node.to_pson).as(%w{a b c})
     end
 
-    it "should include parameters if set" do
+    it "includes parameters if set" do
       @node.parameters = {"a" => "b", "c" => "d"}
-      Puppet::Node.should read_json_attribute('parameters').from(@node.to_pson).as({"a" => "b", "c" => "d"})
+      expect(Puppet::Node).to read_json_attribute('parameters').from(@node.to_pson).as({"a" => "b", "c" => "d"})
     end
 
     it "deserializes environment to environment_name as a string" do
       @node.environment = environment
-      Puppet::Node.should read_json_attribute('environment_name').from(@node.to_pson).as('bar')
+      expect(Puppet::Node).to read_json_attribute('environment_name').from(@node.to_pson).as('bar')
     end
   end
 end
@@ -177,93 +157,105 @@ describe Puppet::Node, "when initializing" do
     @node = Puppet::Node.new("testnode")
   end
 
-  it "should set the node name" do
-    @node.name.should == "testnode"
+  it "sets the node name" do
+    expect(@node.name).to eq("testnode")
   end
 
-  it "should not allow nil node names" do
-    proc { Puppet::Node.new(nil) }.should raise_error(ArgumentError)
+  it "does not allow nil node names" do
+    expect { Puppet::Node.new(nil) }.to raise_error(ArgumentError)
   end
 
-  it "should default to an empty parameter hash" do
-    @node.parameters.should == {}
+  it "defaults to an empty parameter hash" do
+    expect(@node.parameters).to eq({})
   end
 
-  it "should default to an empty class array" do
-    @node.classes.should == []
+  it "defaults to an empty class array" do
+    expect(@node.classes).to eq([])
   end
 
-  it "should note its creation time" do
-    @node.time.should be_instance_of(Time)
+  it "notes its creation time" do
+    expect(@node.time).to be_instance_of(Time)
   end
 
-  it "should accept parameters passed in during initialization" do
+  it "accepts parameters passed in during initialization" do
     params = {"a" => "b"}
     @node = Puppet::Node.new("testing", :parameters => params)
-    @node.parameters.should == params
+    expect(@node.parameters).to eq(params)
   end
 
-  it "should accept classes passed in during initialization" do
+  it "accepts classes passed in during initialization" do
     classes = %w{one two}
     @node = Puppet::Node.new("testing", :classes => classes)
-    @node.classes.should == classes
+    expect(@node.classes).to eq(classes)
   end
 
-  it "should always return classes as an array" do
+  it "always returns classes as an array" do
     @node = Puppet::Node.new("testing", :classes => "myclass")
-    @node.classes.should == ["myclass"]
+    expect(@node.classes).to eq(["myclass"])
   end
 end
 
 describe Puppet::Node, "when merging facts" do
   before do
     @node = Puppet::Node.new("testnode")
-    Puppet::Node::Facts.indirection.stubs(:find).with(@node.name, instance_of(Hash)).returns(Puppet::Node::Facts.new(@node.name, "one" => "c", "two" => "b"))
+    Puppet[:facts_terminus] = :memory
+    Puppet::Node::Facts.indirection.save(Puppet::Node::Facts.new(@node.name, "one" => "c", "two" => "b"))
   end
 
-  it "should fail intelligently if it cannot find facts" do
-    Puppet::Node::Facts.indirection.expects(:find).with(@node.name, instance_of(Hash)).raises "foo"
-    lambda { @node.fact_merge }.should raise_error(Puppet::Error)
+  it "recovers with a Puppet::Error if something is thrown from the facts indirection" do
+    Puppet::Node::Facts.indirection.expects(:find).raises "something bad happened in the indirector"
+    expect { @node.fact_merge }.to raise_error(Puppet::Error, /Could not retrieve facts for testnode: something bad happened in the indirector/)
   end
 
-  it "should prefer parameters already set on the node over facts from the node" do
+  it "prefers parameters already set on the node over facts from the node" do
     @node = Puppet::Node.new("testnode", :parameters => {"one" => "a"})
     @node.fact_merge
-    @node.parameters["one"].should == "a"
+    expect(@node.parameters["one"]).to eq("a")
   end
 
-  it "should add passed parameters to the parameter list" do
+  it "adds passed parameters to the parameter list" do
     @node = Puppet::Node.new("testnode", :parameters => {"one" => "a"})
     @node.fact_merge
-    @node.parameters["two"].should == "b"
+    expect(@node.parameters["two"]).to eq("b")
   end
 
-  it "should accept arbitrary parameters to merge into its parameters" do
+  it "accepts arbitrary parameters to merge into its parameters" do
     @node = Puppet::Node.new("testnode", :parameters => {"one" => "a"})
     @node.merge "two" => "three"
-    @node.parameters["two"].should == "three"
+    expect(@node.parameters["two"]).to eq("three")
   end
 
-  it "should add the environment to the list of parameters" do
-    Puppet[:environment] = "one"
-    @node = Puppet::Node.new("testnode", :environment => "one")
-    @node.merge "two" => "three"
-    @node.parameters["environment"].should == "one"
-  end
+  context "with an env loader" do
+    let(:environment) { Puppet::Node::Environment.create(:one, []) }
+    let(:env_loader) { Puppet::Environments::Static.new(environment) }
+
+    around do |example|
+      Puppet.override(:environments => env_loader) do
+        example.run
+      end
+    end
+
+    it "adds the environment to the list of parameters" do
+      Puppet[:environment] = "one"
+      @node = Puppet::Node.new("testnode", :environment => "one")
+      @node.merge "two" => "three"
+      expect(@node.parameters["environment"]).to eq("one")
+    end
 
-  it "should not set the environment if it is already set in the parameters" do
-    Puppet[:environment] = "one"
-    @node = Puppet::Node.new("testnode", :environment => "one")
-    @node.merge "environment" => "two"
-    @node.parameters["environment"].should == "two"
+    it "nots set the environment if it is already set in the parameters" do
+      Puppet[:environment] = "one"
+      @node = Puppet::Node.new("testnode", :environment => "one")
+      @node.merge "environment" => "two"
+      expect(@node.parameters["environment"]).to eq("two")
+    end
   end
 end
 
 describe Puppet::Node, "when indirecting" do
-  it "should default to the 'plain' node terminus" do
+  it "defaults to the 'plain' node terminus" do
     Puppet::Node.indirection.reset_terminus_class
 
-    Puppet::Node.indirection.terminus_class.should == :plain
+    expect(Puppet::Node.indirection.terminus_class).to eq(:plain)
   end
 end
 
@@ -272,30 +264,30 @@ describe Puppet::Node, "when generating the list of names to search through" do
     @node = Puppet::Node.new("foo.domain.com", :parameters => {"hostname" => "yay", "domain" => "domain.com"})
   end
 
-  it "should return an array of names" do
-    @node.names.should be_instance_of(Array)
+  it "returns an array of names" do
+    expect(@node.names).to be_instance_of(Array)
   end
 
   describe "and the node name is fully qualified" do
-    it "should contain an entry for each part of the node name" do
-      @node.names.should be_include("foo.domain.com")
-      @node.names.should be_include("foo.domain")
-      @node.names.should be_include("foo")
+    it "contains an entry for each part of the node name" do
+      expect(@node.names).to include("foo.domain.com")
+      expect(@node.names).to include("foo.domain")
+      expect(@node.names).to include("foo")
     end
   end
 
-  it "should include the node's fqdn" do
-    @node.names.should be_include("yay.domain.com")
+  it "includes the node's fqdn" do
+    expect(@node.names).to include("yay.domain.com")
   end
 
-  it "should combine and include the node's hostname and domain if no fqdn is available" do
-    @node.names.should be_include("yay.domain.com")
+  it "combines and include the node's hostname and domain if no fqdn is available" do
+    expect(@node.names).to include("yay.domain.com")
   end
 
-  it "should contain an entry for each name available by stripping a segment of the fqdn" do
+  it "contains an entry for each name available by stripping a segment of the fqdn" do
     @node.parameters["fqdn"] = "foo.deep.sub.domain.com"
-    @node.names.should be_include("foo.deep.sub.domain")
-    @node.names.should be_include("foo.deep.sub")
+    expect(@node.names).to include("foo.deep.sub.domain")
+    expect(@node.names).to include("foo.deep.sub")
   end
 
   describe "and :node_name is set to 'cert'" do
@@ -304,14 +296,14 @@ describe Puppet::Node, "when generating the list of names to search through" do
       Puppet[:node_name] = "cert"
     end
 
-    it "should use the passed-in key as the first value" do
-      @node.names[0].should == "foo.domain.com"
+    it "uses the passed-in key as the first value" do
+      expect(@node.names[0]).to eq("foo.domain.com")
     end
 
     describe "and strict hostname checking is enabled" do
-      it "should only use the passed-in key" do
+      it "only uses the passed-in key" do
         Puppet[:strict_hostname_checking] = true
-        @node.names.should == ["foo.domain.com"]
+        expect(@node.names).to eq(["foo.domain.com"])
       end
     end
   end
@@ -322,8 +314,8 @@ describe Puppet::Node, "when generating the list of names to search through" do
       Puppet[:node_name] = "facter"
     end
 
-    it "should use the node's 'hostname' fact as the first value" do
-      @node.names[0].should == "yay"
+    it "uses the node's 'hostname' fact as the first value" do
+      expect(@node.names[0]).to eq("yay")
     end
   end
 end