puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/indirector/report/processor_spec.rb

@@ -9,11 +9,11 @@ describe Puppet::Transaction::Report::Processor do
   end
 
   it "should provide a method for saving reports" do
-    Puppet::Transaction::Report::Processor.new.should respond_to(:save)
+    expect(Puppet::Transaction::Report::Processor.new).to respond_to(:save)
   end
 
   it "should provide a method for cleaning reports" do
-    Puppet::Transaction::Report::Processor.new.should respond_to(:destroy)
+    expect(Puppet::Transaction::Report::Processor.new).to respond_to(:destroy)
   end
 
 end
@@ -38,7 +38,7 @@ describe Puppet::Transaction::Report::Processor, " when processing a report" do
 
   it "should save the report with each configured report type" do
     Puppet[:reports] = "one,two"
-    @reporter.send(:reports).should == %w{one two}
+    expect(@reporter.send(:reports)).to eq(%w{one two})
 
     Puppet::Reports.expects(:report).with('one')
     Puppet::Reports.expects(:report).with('two')
@@ -95,6 +95,6 @@ describe Puppet::Transaction::Report::Processor, " when processing a report" do
   it "should not raise exceptions" do
     Puppet[:trace] = false
     @dup_report.expects(:process).raises(ArgumentError)
-    proc { @reporter.save(@request) }.should_not raise_error
+    expect { @reporter.save(@request) }.not_to raise_error
   end
 end

data/spec/unit/indirector/report/rest_spec.rb

@@ -5,22 +5,22 @@ require 'puppet/indirector/report/rest'
 
 describe Puppet::Transaction::Report::Rest do
   it "should be a subclass of Puppet::Indirector::REST" do
-    Puppet::Transaction::Report::Rest.superclass.should equal(Puppet::Indirector::REST)
+    expect(Puppet::Transaction::Report::Rest.superclass).to equal(Puppet::Indirector::REST)
   end
 
   it "should use the :report_server setting in preference to :server" do
     Puppet.settings[:server] = "server"
     Puppet.settings[:report_server] = "report_server"
-    Puppet::Transaction::Report::Rest.server.should == "report_server"
+    expect(Puppet::Transaction::Report::Rest.server).to eq("report_server")
   end
 
   it "should have a value for report_server and report_port" do
-    Puppet::Transaction::Report::Rest.server.should_not be_nil
-    Puppet::Transaction::Report::Rest.port.should_not be_nil
+    expect(Puppet::Transaction::Report::Rest.server).not_to be_nil
+    expect(Puppet::Transaction::Report::Rest.port).not_to be_nil
   end
 
   it "should use the :report SRV service" do
-    Puppet::Transaction::Report::Rest.srv_service.should == :report
+    expect(Puppet::Transaction::Report::Rest.srv_service).to eq(:report)
   end
 
   let(:model) { Puppet::Transaction::Report }
@@ -57,11 +57,11 @@ describe Puppet::Transaction::Report::Rest do
 
     it "deserializes the response as an array of report processor names" do
       processors = ["store", "http"]
-      body = YAML.dump(processors)
-      response = mock_response('200', body, 'text/yaml')
+      body = processors.to_pson()
+      response = mock_response('200', body, 'text/pson')
       connection.expects(:put).returns response
 
-      terminus.save(request).should == ["store", "http"]
+      expect(terminus.save(request)).to eq(["store", "http"])
     end
   end
 end

data/spec/unit/indirector/report/yaml_spec.rb

@@ -6,23 +6,23 @@ require 'puppet/indirector/report/yaml'
 
 describe Puppet::Transaction::Report::Yaml do
   it "should be a subclass of the Yaml terminus" do
-    Puppet::Transaction::Report::Yaml.superclass.should equal(Puppet::Indirector::Yaml)
+    expect(Puppet::Transaction::Report::Yaml.superclass).to equal(Puppet::Indirector::Yaml)
   end
 
   it "should have documentation" do
-    Puppet::Transaction::Report::Yaml.doc.should_not be_nil
+    expect(Puppet::Transaction::Report::Yaml.doc).not_to be_nil
   end
 
   it "should be registered with the report indirection" do
     indirection = Puppet::Indirector::Indirection.instance(:report)
-    Puppet::Transaction::Report::Yaml.indirection.should equal(indirection)
+    expect(Puppet::Transaction::Report::Yaml.indirection).to equal(indirection)
   end
 
   it "should have its name set to :yaml" do
-    Puppet::Transaction::Report::Yaml.name.should == :yaml
+    expect(Puppet::Transaction::Report::Yaml.name).to eq(:yaml)
   end
 
   it "should unconditionally save/load from the --lastrunreport setting" do
-    subject.path(:me).should == Puppet[:lastrunreport]
+    expect(subject.path(:me)).to eq(Puppet[:lastrunreport])
   end
 end

data/spec/unit/indirector/request_spec.rb

@@ -2,35 +2,28 @@
 require 'spec_helper'
 require 'matchers/json'
 require 'puppet/indirector/request'
-require 'puppet/util/pson'
 
 describe Puppet::Indirector::Request do
   include JSONMatchers
 
-  describe "when registering the document type" do
-    it "should register its document type with JSON" do
-      PSON.registered_document_types["IndirectorRequest"].should equal(Puppet::Indirector::Request)
-    end
-  end
-
   describe "when initializing" do
     it "should always convert the indirection name to a symbol" do
-      Puppet::Indirector::Request.new("ind", :method, "mykey", nil).indirection_name.should == :ind
+      expect(Puppet::Indirector::Request.new("ind", :method, "mykey", nil).indirection_name).to eq(:ind)
     end
 
     it "should use provided value as the key if it is a string" do
-      Puppet::Indirector::Request.new(:ind, :method, "mykey", nil).key.should == "mykey"
+      expect(Puppet::Indirector::Request.new(:ind, :method, "mykey", nil).key).to eq("mykey")
     end
 
     it "should use provided value as the key if it is a symbol" do
-      Puppet::Indirector::Request.new(:ind, :method, :mykey, nil).key.should == :mykey
+      expect(Puppet::Indirector::Request.new(:ind, :method, :mykey, nil).key).to eq(:mykey)
     end
 
     it "should use the name of the provided instance as its key if an instance is provided as the key instead of a string" do
       instance = mock 'instance', :name => "mykey"
       request = Puppet::Indirector::Request.new(:ind, :method, nil, instance)
-      request.key.should == "mykey"
-      request.instance.should equal(instance)
+      expect(request.key).to eq("mykey")
+      expect(request.instance).to equal(instance)
     end
 
     it "should support options specified as a hash" do
@@ -46,51 +39,59 @@ describe Puppet::Indirector::Request do
     end
 
     it "should use an empty options hash if nil was provided" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil, nil).options.should == {}
+      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, nil).options).to eq({})
     end
 
     it "should default to a nil node" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil).node.should be_nil
+      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil).node).to be_nil
     end
 
     it "should set its node attribute if provided in the options" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :node => "foo.com").node.should == "foo.com"
+      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :node => "foo.com").node).to eq("foo.com")
     end
 
     it "should default to a nil ip" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil).ip.should be_nil
+      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil).ip).to be_nil
     end
 
     it "should set its ip attribute if provided in the options" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ip => "192.168.0.1").ip.should == "192.168.0.1"
+      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ip => "192.168.0.1").ip).to eq("192.168.0.1")
     end
 
     it "should default to being unauthenticated" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil).should_not be_authenticated
+      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil)).not_to be_authenticated
     end
 
     it "should set be marked authenticated if configured in the options" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :authenticated => "eh").should be_authenticated
+      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :authenticated => "eh")).to be_authenticated
     end
 
     it "should keep its options as a hash even if a node is specified" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :node => "eh").options.should be_instance_of(Hash)
+      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :node => "eh").options).to be_instance_of(Hash)
     end
 
     it "should keep its options as a hash even if another option is specified" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :foo => "bar").options.should be_instance_of(Hash)
+      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :foo => "bar").options).to be_instance_of(Hash)
     end
 
     it "should treat options other than :ip, :node, and :authenticated as options rather than attributes" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :server => "bar").options[:server].should == "bar"
+      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :server => "bar").options[:server]).to eq("bar")
     end
 
     it "should normalize options to use symbols as keys" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil, "foo" => "bar").options[:foo].should == "bar"
+      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, "foo" => "bar").options[:foo]).to eq("bar")
     end
 
     describe "and the request key is a URI" do
       let(:file) { File.expand_path("/my/file with spaces") }
+      let(:an_environment) { Puppet::Node::Environment.create(:an_environment, []) }
+      let(:env_loaders) { Puppet::Environments::Static.new(an_environment) }
+
+      around(:each) do |example|
+        Puppet.override({ :environments => env_loaders }, "Static environment loader for specs") do
+          example.run
+        end
+      end
 
       describe "and the URI is a 'file' URI" do
         before do
@@ -98,74 +99,74 @@ describe Puppet::Indirector::Request do
         end
 
         it "should set the request key to the unescaped full file path" do
-          @request.key.should == file
+          expect(@request.key).to eq(file)
         end
 
         it "should not set the protocol" do
-          @request.protocol.should be_nil
+          expect(@request.protocol).to be_nil
         end
 
         it "should not set the port" do
-          @request.port.should be_nil
+          expect(@request.port).to be_nil
         end
 
         it "should not set the server" do
-          @request.server.should be_nil
+          expect(@request.server).to be_nil
         end
       end
 
       it "should set the protocol to the URI scheme" do
-        Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff", nil).protocol.should == "http"
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment", nil).protocol).to eq("http")
       end
 
       it "should set the server if a server is provided" do
-        Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff", nil).server.should == "host"
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment", nil).server).to eq("host")
       end
 
       it "should set the server and port if both are provided" do
-        Puppet::Indirector::Request.new(:ind, :method, "http://host:543/stuff", nil).port.should == 543
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host:543/an_environment", nil).port).to eq(543)
       end
 
       it "should default to the masterport if the URI scheme is 'puppet'" do
         Puppet[:masterport] = "321"
-        Puppet::Indirector::Request.new(:ind, :method, "puppet://host/stuff", nil).port.should == 321
+        expect(Puppet::Indirector::Request.new(:ind, :method, "puppet://host/an_environment", nil).port).to eq(321)
       end
 
       it "should use the provided port if the URI scheme is not 'puppet'" do
-        Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff", nil).port.should == 80
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment", nil).port).to eq(80)
       end
 
       it "should set the request key to the unescaped key part path from the URI" do
-        Puppet::Indirector::Request.new(:ind, :method, "http://host/environment/terminus/stuff with spaces", nil).key.should == "stuff with spaces"
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment/terminus/stuff with spaces", nil).key).to eq("stuff with spaces")
       end
 
       it "should set the :uri attribute to the full URI" do
-        Puppet::Indirector::Request.new(:ind, :method, "http:///stu ff", nil).uri.should == 'http:///stu ff'
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http:///an_environment/stu ff", nil).uri).to eq('http:///an_environment/stu ff')
       end
 
       it "should not parse relative URI" do
-        Puppet::Indirector::Request.new(:ind, :method, "foo/bar", nil).uri.should be_nil
+        expect(Puppet::Indirector::Request.new(:ind, :method, "foo/bar", nil).uri).to be_nil
       end
 
       it "should not parse opaque URI" do
-        Puppet::Indirector::Request.new(:ind, :method, "mailto:joe", nil).uri.should be_nil
+        expect(Puppet::Indirector::Request.new(:ind, :method, "mailto:joe", nil).uri).to be_nil
       end
     end
 
     it "should allow indication that it should not read a cached instance" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ignore_cache => true).should be_ignore_cache
+      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ignore_cache => true)).to be_ignore_cache
     end
 
     it "should default to not ignoring the cache" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil).should_not be_ignore_cache
+      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil)).not_to be_ignore_cache
     end
 
     it "should allow indication that it should not not read an instance from the terminus" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ignore_terminus => true).should be_ignore_terminus
+      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ignore_terminus => true)).to be_ignore_terminus
     end
 
     it "should default to not ignoring the terminus" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil).should_not be_ignore_terminus
+      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil)).not_to be_ignore_terminus
     end
   end
 
@@ -174,7 +175,7 @@ describe Puppet::Indirector::Request do
     Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
     request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
-    request.indirection.should equal(ind)
+    expect(request.indirection).to equal(ind)
   end
 
   it "should use its indirection to look up the appropriate model" do
@@ -184,7 +185,7 @@ describe Puppet::Indirector::Request do
 
     ind.expects(:model).returns "mymodel"
 
-    request.model.should == "mymodel"
+    expect(request.model).to eq("mymodel")
   end
 
   it "should fail intelligently when asked to find a model but the indirection cannot be found" do
@@ -195,41 +196,47 @@ describe Puppet::Indirector::Request do
   end
 
   it "should have a method for determining if the request is plural or singular" do
-    Puppet::Indirector::Request.new(:myind, :method, :key, nil).should respond_to(:plural?)
+    expect(Puppet::Indirector::Request.new(:myind, :method, :key, nil)).to respond_to(:plural?)
   end
 
   it "should be considered plural if the method is 'search'" do
-    Puppet::Indirector::Request.new(:myind, :search, :key, nil).should be_plural
+    expect(Puppet::Indirector::Request.new(:myind, :search, :key, nil)).to be_plural
   end
 
   it "should not be considered plural if the method is not 'search'" do
-    Puppet::Indirector::Request.new(:myind, :find, :key, nil).should_not be_plural
+    expect(Puppet::Indirector::Request.new(:myind, :find, :key, nil)).not_to be_plural
   end
 
-  it "should use its uri, if it has one, as its string representation" do
-    Puppet::Indirector::Request.new(:myind, :find, "foo://bar/baz", nil).to_s.should == "foo://bar/baz"
+  it "should use its uri, if it has one, as its description" do
+    Puppet.override({
+      :environments => Puppet::Environments::Static.new(
+        Puppet::Node::Environment.create(:baz, [])
+    )},
+      "Static loader for spec") do
+      expect(Puppet::Indirector::Request.new(:myind, :find, "foo://bar/baz", nil).description).to eq("foo://bar/baz")
+      end
   end
 
-  it "should use its indirection name and key, if it has no uri, as its string representation" do
-    Puppet::Indirector::Request.new(:myind, :find, "key", nil) == "/myind/key"
+  it "should use its indirection name and key, if it has no uri, as its description" do
+    expect(Puppet::Indirector::Request.new(:myind, :find, "key", nil).description).to eq("/myind/key")
   end
 
   it "should be able to return the URI-escaped key" do
-    Puppet::Indirector::Request.new(:myind, :find, "my key", nil).escaped_key.should == URI.escape("my key")
+    expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil).escaped_key).to eq(URI.escape("my key"))
   end
 
   it "should set its environment to an environment instance when a string is specified as its environment" do
     env = Puppet::Node::Environment.create(:foo, [])
 
     Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
-      Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => "foo").environment.should == env
+      expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => "foo").environment).to eq(env)
     end
   end
 
   it "should use any passed in environment instances as its environment" do
     env = Puppet::Node::Environment.create(:foo, [])
 
-    Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => env).environment.should equal(env)
+    expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => env).environment).to equal(env)
   end
 
   it "should use the current environment when none is provided" do
@@ -241,11 +248,11 @@ describe Puppet::Indirector::Request do
   end
 
   it "should support converting its options to a hash" do
-    Puppet::Indirector::Request.new(:myind, :find, "my key", nil ).should respond_to(:to_hash)
+    expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil )).to respond_to(:to_hash)
   end
 
   it "should include all of its attributes when its options are converted to a hash" do
-    Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :node => 'foo').to_hash[:node].should == 'foo'
+    expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :node => 'foo').to_hash[:node]).to eq('foo')
   end
 
   describe "when building a query string from its options" do
@@ -260,101 +267,86 @@ describe Puppet::Indirector::Request do
     it "should return an empty query string if there are no options" do
       request = a_request_with_options(nil)
 
-      request.query_string.should == ""
+      expect(request.query_string).to eq("")
     end
 
     it "should return an empty query string if the options are empty" do
       request = a_request_with_options({})
 
-      request.query_string.should == ""
-    end
-
-    it "should prefix the query string with '?'" do
-      request = a_request_with_options(:one => "two")
-
-      request.query_string.should =~ /^\?/
+      expect(request.query_string).to eq("")
     end
 
     it "should include all options in the query string, separated by '&'" do
       request = a_request_with_options(:one => "two", :three => "four")
 
-      the_parsed_query_string_from(request).should == {
+      expect(the_parsed_query_string_from(request)).to eq({
         "one" => ["two"],
         "three" => ["four"]
-      }
+      })
     end
 
     it "should ignore nil options" do
       request = a_request_with_options(:one => "two", :three => nil)
 
-      the_parsed_query_string_from(request).should == {
+      expect(the_parsed_query_string_from(request)).to eq({
         "one" => ["two"]
-      }
+      })
     end
 
     it "should convert 'true' option values into strings" do
       request = a_request_with_options(:one => true)
 
-      the_parsed_query_string_from(request).should == {
+      expect(the_parsed_query_string_from(request)).to eq({
         "one" => ["true"]
-      }
+      })
     end
 
     it "should convert 'false' option values into strings" do
       request = a_request_with_options(:one => false)
 
-      the_parsed_query_string_from(request).should == {
+      expect(the_parsed_query_string_from(request)).to eq({
         "one" => ["false"]
-      }
+      })
     end
 
     it "should convert to a string all option values that are integers" do
       request = a_request_with_options(:one => 50)
 
-      the_parsed_query_string_from(request).should == {
+      expect(the_parsed_query_string_from(request)).to eq({
         "one" => ["50"]
-      }
+      })
     end
 
     it "should convert to a string all option values that are floating point numbers" do
       request = a_request_with_options(:one => 1.2)
 
-      the_parsed_query_string_from(request).should == {
+      expect(the_parsed_query_string_from(request)).to eq({
         "one" => ["1.2"]
-      }
+      })
     end
 
     it "should CGI-escape all option values that are strings" do
       request = a_request_with_options(:one => "one two")
 
-      the_parsed_query_string_from(request).should == {
+      expect(the_parsed_query_string_from(request)).to eq({
         "one" => ["one two"]
-      }
+      })
     end
 
     it "should convert an array of values into multiple entries for the same key" do
       request = a_request_with_options(:one => %w{one two})
 
-      the_parsed_query_string_from(request).should == {
+      expect(the_parsed_query_string_from(request)).to eq({
         "one" => ["one", "two"]
-      }
-    end
-
-    it "should convert an array of values into a single yaml entry when in legacy mode" do
-      Puppet[:legacy_query_parameter_serialization] = true
-      request = a_request_with_options(:one => %w{one two})
-
-      the_parsed_query_string_from(request).should == {
-          "one" => ["--- \n  - one\n  - two"]
-      }
+      })
     end
 
     it "should stringify simple data types inside an array" do
       request = a_request_with_options(:one => ['one', nil])
 
-      the_parsed_query_string_from(request).should == {
+      expect(the_parsed_query_string_from(request)).to eq({
         "one" => ["one"]
-      }
+      })
     end
 
     it "should error if an array contains another array" do
@@ -372,9 +364,9 @@ describe Puppet::Indirector::Request do
     it "should convert to a string and CGI-escape all option values that are symbols" do
       request = a_request_with_options(:one => :"sym bol")
 
-      the_parsed_query_string_from(request).should == {
+      expect(the_parsed_query_string_from(request)).to eq({
         "one" => ["sym bol"]
-      }
+      })
     end
 
     it "should fail if options other than booleans or strings are provided" do
@@ -384,101 +376,6 @@ describe Puppet::Indirector::Request do
     end
   end
 
-  describe "when converting to json" do
-    before do
-      @request = Puppet::Indirector::Request.new(:facts, :find, "foo", nil)
-    end
-
-    it "should produce a hash with the document_type set to 'request'" do
-      @request.should set_json_document_type_to("IndirectorRequest")
-    end
-
-    it "should set the 'key'" do
-      @request.should set_json_attribute("key").to("foo")
-    end
-
-    it "should include an attribute for its indirection name" do
-      @request.should set_json_attribute("type").to("facts")
-    end
-
-    it "should include a 'method' attribute set to its method" do
-      @request.should set_json_attribute("method").to("find")
-    end
-
-    it "should add all attributes under the 'attributes' attribute" do
-      @request.ip = "127.0.0.1"
-      @request.should set_json_attribute("attributes", "ip").to("127.0.0.1")
-    end
-
-    it "should add all options under the 'attributes' attribute" do
-      @request.options["opt"] = "value"
-      PSON.parse(@request.to_pson)["data"]['attributes']['opt'].should == "value"
-    end
-
-    it "should include the instance if provided" do
-      facts = Puppet::Node::Facts.new("foo")
-      @request.instance = facts
-      PSON.parse(@request.to_pson)["data"]['instance'].should be_instance_of(Hash)
-    end
-  end
-
-  describe "when converting from json" do
-    before do
-      @request = Puppet::Indirector::Request.new(:facts, :find, "foo", nil)
-      @klass = Puppet::Indirector::Request
-      @format = Puppet::Network::FormatHandler.format('pson')
-    end
-
-    def from_json(json)
-      @format.intern(Puppet::Indirector::Request, json)
-    end
-
-    it "should set the 'key'" do
-      from_json(@request.to_pson).key.should == "foo"
-    end
-
-    it "should fail if no key is provided" do
-      json = PSON.parse(@request.to_pson)
-      json['data'].delete("key")
-      expect { from_json(json.to_pson) }.to raise_error(ArgumentError)
-    end
-
-    it "should set its indirector name" do
-      from_json(@request.to_pson).indirection_name.should == :facts
-    end
-
-    it "should fail if no type is provided" do
-      json = PSON.parse(@request.to_pson)
-      json['data'].delete("type")
-      expect { from_json(json.to_pson) }.to raise_error(ArgumentError)
-    end
-
-    it "should set its method" do
-      from_json(@request.to_pson).method.should == "find"
-    end
-
-    it "should fail if no method is provided" do
-      json = PSON.parse(@request.to_pson)
-      json['data'].delete("method")
-      expect { from_json(json.to_pson) }.to raise_error(ArgumentError)
-    end
-
-    it "should initialize with all attributes and options" do
-      @request.ip = "127.0.0.1"
-      @request.options["opt"] = "value"
-      result = from_json(@request.to_pson)
-      result.options[:opt].should == "value"
-      result.ip.should == "127.0.0.1"
-    end
-
-    it "should set its instance as an instance if one is provided" do
-      facts = Puppet::Node::Facts.new("foo")
-      @request.instance = facts
-      result = from_json(@request.to_pson)
-      result.instance.should be_instance_of(Puppet::Node::Facts)
-    end
-  end
-
   context '#do_request' do
     before :each do
       @request = Puppet::Indirector::Request.new(:myind, :find, "my key", nil)
@@ -493,13 +390,13 @@ describe Puppet::Indirector::Request do
         count = 0
         rval = @request.do_request(:puppet, 'puppet.example.com', '90210') do |got|
           count += 1
-          got.server.should == 'puppet.example.com'
-          got.port.should   == '90210'
+          expect(got.server).to eq('puppet.example.com')
+          expect(got.port).to   eq('90210')
           'Block return value'
         end
-        count.should == 1
+        expect(count).to eq(1)
 
-        rval.should == 'Block return value'
+        expect(rval).to eq('Block return value')
       end
     end
 
@@ -516,13 +413,13 @@ describe Puppet::Indirector::Request do
         count = 0
         rval = @request.do_request do |got|
           count += 1
-          got.server.should == 'puppet.example.com'
-          got.port.should   == '90210'
+          expect(got.server).to eq('puppet.example.com')
+          expect(got.port).to   eq('90210')
           'Block return value'
         end
-        count.should == 1
+        expect(count).to eq(1)
 
-        rval.should == 'Block return value'
+        expect(rval).to eq('Block return value')
       end
 
       context "when SRV returns servers" do
@@ -543,14 +440,14 @@ describe Puppet::Indirector::Request do
           count = 0
           rval = @request.do_request do |got|
             count += 1
-            got.server.should == '_x-puppet._tcp.example.com'
-            got.port.should == 7205
+            expect(got.server).to eq('_x-puppet._tcp.example.com')
+            expect(got.port).to eq(7205)
 
             @block_return
           end
-          count.should == 1
+          expect(count).to eq(1)
 
-          rval.should == @block_return
+          expect(rval).to eq(@block_return)
         end
 
         it "should fall back to the default server when the block raises a SystemCallError" do
@@ -569,11 +466,11 @@ describe Puppet::Indirector::Request do
             @block_return
           end
 
-          second_pass.server.should == 'puppet'
-          second_pass.port.should   == 8140
-          count.should == 2
+          expect(second_pass.server).to eq('puppet')
+          expect(second_pass.port).to   eq(8140)
+          expect(count).to eq(2)
 
-          rval.should == @block_return
+          expect(rval).to eq(@block_return)
         end
       end
     end
@@ -585,19 +482,19 @@ describe Puppet::Indirector::Request do
     end
 
     it "should not be unless node or ip is set" do
-      request.should_not be_remote
+      expect(request).not_to be_remote
     end
 
     it "should be remote if node is set" do
-      request(:node => 'example.com').should be_remote
+      expect(request(:node => 'example.com')).to be_remote
     end
 
     it "should be remote if ip is set" do
-      request(:ip => '127.0.0.1').should be_remote
+      expect(request(:ip => '127.0.0.1')).to be_remote
     end
 
     it "should be remote if node and ip are set" do
-      request(:node => 'example.com', :ip => '127.0.0.1').should be_remote
+      expect(request(:node => 'example.com', :ip => '127.0.0.1')).to be_remote
     end
   end
 end