puppet 2.7.26 → 3.0.0.rc4

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/indirector/node/memory'

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

@@ -1,18 +1,26 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/indirector/node/plain'
 
 describe Puppet::Node::Plain do
+  let(:nodename) { "mynode" }
+  let(:fact_values) { {:afact => "a value"} }
+  let(:facts) { Puppet::Node::Facts.new(nodename, fact_values) }
+  let(:environment) { Puppet::Node::Environment.new("myenv") }
+  let(:request) { Puppet::Indirector::Request.new(:node, :find, nodename, nil, :environment => environment) }
+  let(:node_indirection) { Puppet::Node::Plain.new }
+
   before do
-    @searcher = Puppet::Node::Plain.new
+    Puppet::Node::Facts.indirection.expects(:find).with(nodename, :environment => environment).returns(facts)
+  end
+
+  it "merges facts into the node" do
+    node_indirection.find(request).parameters.should include(fact_values)
   end
 
-  it "should call node_merge() on the returned node" do
-    node = mock 'node'
-    Puppet::Node.expects(:new).with("mynode").returns(node)
-    node.expects(:fact_merge)
-    request = stub 'request', :key => "mynode"
-    @searcher.find(request)
+  it "should set the node environment from the request" do
+    node_indirection.find(request).environment.should == environment
   end
+
 end

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/indirector/node/rest'

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/node'
 require 'puppet/indirector/memory'

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/node'

data/spec/unit/indirector/none_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'puppet/indirector/none'
+
+describe Puppet::Indirector::None do
+  before do
+    Puppet::Indirector::Terminus.stubs(:register_terminus_class)
+    Puppet::Indirector::Indirection.stubs(:instance).returns(indirection)
+
+    module Testing; end
+    @none_class = class Testing::None < Puppet::Indirector::None
+      self
+    end
+
+    @data_binder = @none_class.new
+  end
+
+  let(:model)   { mock('model') }
+  let(:request) { stub('request', :key => "port") }
+  let(:indirection) do
+    stub('indirection', :name => :none, :register_terminus_type => nil,
+      :model => model)
+  end
+
+  it "should not be the default data_binding_terminus" do
+    Puppet.settings[:data_binding_terminus].should_not == 'none'
+  end
+
+  describe "the behavior of the find method" do
+    it "should just return nil" do
+      @data_binder.find(request).should be_nil
+    end
+  end
+end

data/spec/unit/indirector/plain_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/indirector/plain'
 

data/spec/unit/indirector/queue_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/indirector/queue'
 

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/indirector/report/processor'
@@ -29,7 +29,7 @@ describe Puppet::Transaction::Report::Processor, " when processing a report" do
     Puppet::Reports.expects(:report).never
     Puppet[:reports] = 'none'
 
-    request = Puppet::Indirector::Request.new(:indirection_name, :head, "key")
+    request = Puppet::Indirector::Request.new(:indirection_name, :head, "key", nil)
     report = Puppet::Transaction::Report.new('apply')
     request.instance = report
 
@@ -37,7 +37,7 @@ describe Puppet::Transaction::Report::Processor, " when processing a report" do
   end
 
   it "should save the report with each configured report type" do
-    Puppet.settings.stubs(:value).with(:reports).returns("one,two")
+    Puppet[:reports] = "one,two"
     @reporter.send(:reports).should == %w{one two}
 
     Puppet::Reports.expects(:report).with('one')
@@ -47,7 +47,7 @@ describe Puppet::Transaction::Report::Processor, " when processing a report" do
   end
 
   it "should destroy reports for each processor that responds to destroy" do
-    Puppet.settings.stubs(:value).with(:reports).returns("http,store")
+    Puppet[:reports] = "http,store"
     http_report = mock()
     store_report = mock()
     store_report.expects(:destroy).with(@request.key)

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/indirector/report/rest'
@@ -8,12 +8,6 @@ describe Puppet::Transaction::Report::Rest do
     Puppet::Transaction::Report::Rest.superclass.should equal(Puppet::Indirector::REST)
   end
 
-  it "should use the :report_server setting in preference to :reportserver" do
-    Puppet.settings[:reportserver] = "reportserver"
-    Puppet.settings[:report_server] = "report_server"
-    Puppet::Transaction::Report::Rest.server.should == "report_server"
-  end
-
   it "should use the :report_server setting in preference to :server" do
     Puppet.settings[:server] = "server"
     Puppet.settings[:report_server] = "report_server"
@@ -25,44 +19,7 @@ describe Puppet::Transaction::Report::Rest do
     Puppet::Transaction::Report::Rest.port.should_not be_nil
   end
 
-  let(:model) { Puppet::Transaction::Report }
-  let(:terminus_class) { Puppet::Transaction::Report::Rest }
-  let(:terminus) { model.indirection.terminus(:rest) }
-  let(:indirection) { model.indirection }
-
-  before(:each) do
-    Puppet::Transaction::Report.indirection.terminus_class = :rest
-  end
-
-  def mock_response(code, body, content_type='text/plain', encoding=nil)
-    obj = stub('http 200 ok', :code => code.to_s, :body => body)
-    obj.stubs(:[]).with('content-type').returns(content_type)
-    obj.stubs(:[]).with('content-encoding').returns(encoding)
-    obj
-  end
-
-  def save_request(key, instance)
-    Puppet::Indirector::Request.new(:report, :find, key, instance)
-  end
-
-  describe "#save" do
-    let(:http_method) { :put }
-    let(:response) { mock_response(200, 'body') }
-    let(:connection) { stub('mock http connection', :put => response, :verify_callback= => nil) }
-    let(:instance) { model.new('the thing', 'some contents') }
-    let(:request) { save_request(instance.name, instance) }
-
-    before :each do
-      terminus.stubs(:network).returns(connection)
-    end
-
-    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')
-      connection.expects(:put).returns response
-
-      terminus.save(request).should == ["store", "http"]
-    end
+  it "should use the :report SRV service" do
+    Puppet::Transaction::Report::Rest.srv_service.should == :report
   end
 end

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/transaction/report'
@@ -22,16 +22,7 @@ describe Puppet::Transaction::Report::Yaml do
     Puppet::Transaction::Report::Yaml.name.should == :yaml
   end
 
-  it "should inconditionnally save/load from the --lastrunreport setting", :'fails_on_ruby_1.9.2' => true do
-    indirection = stub 'indirection', :name => :my_yaml, :register_terminus_type => nil
-    Puppet::Indirector::Indirection.stubs(:instance).with(:my_yaml).returns(indirection)
-    store_class = Class.new(Puppet::Transaction::Report::Yaml) do
-      def self.to_s
-        "MyYaml::MyType"
-      end
-    end
-    store = store_class.new
-
-    store.path(:me).should == Puppet[:lastrunreport]
+  it "should unconditionally save/load from the --lastrunreport setting" do
+    subject.path(:me).should == Puppet[:lastrunreport]
   end
 end

data/spec/unit/indirector/request_spec.rb

@@ -1,47 +1,51 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'matchers/json'
 require 'puppet/indirector/request'
+require 'puppet/util/pson'
 
 describe Puppet::Indirector::Request do
-  describe "when initializing" do
-    it "should require an indirection name, a key, and a method" do
-      lambda { Puppet::Indirector::Request.new }.should raise_error(ArgumentError)
+
+  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").indirection_name.should == :ind
+      Puppet::Indirector::Request.new("ind", :method, "mykey", nil).indirection_name.should == :ind
     end
 
     it "should use provided value as the key if it is a string" do
-      Puppet::Indirector::Request.new(:ind, :method, "mykey").key.should == "mykey"
+      Puppet::Indirector::Request.new(:ind, :method, "mykey", nil).key.should == "mykey"
     end
 
     it "should use provided value as the key if it is a symbol" do
-      Puppet::Indirector::Request.new(:ind, :method, :mykey).key.should == :mykey
+      Puppet::Indirector::Request.new(:ind, :method, :mykey, nil).key.should == :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, instance)
+      request = Puppet::Indirector::Request.new(:ind, :method, nil, instance)
       request.key.should == "mykey"
       request.instance.should equal(instance)
     end
 
     it "should support options specified as a hash" do
-      lambda { Puppet::Indirector::Request.new(:ind, :method, :key, :one => :two) }.should_not raise_error(ArgumentError)
+      lambda { Puppet::Indirector::Request.new(:ind, :method, :key, nil, :one => :two) }.should_not raise_error(ArgumentError)
     end
 
     it "should support nil options" do
-      lambda { Puppet::Indirector::Request.new(:ind, :method, :key, nil) }.should_not raise_error(ArgumentError)
+      lambda { Puppet::Indirector::Request.new(:ind, :method, :key, nil, nil) }.should_not raise_error(ArgumentError)
     end
 
     it "should support unspecified options" do
-      lambda { Puppet::Indirector::Request.new(:ind, :method, :key) }.should_not raise_error(ArgumentError)
+      lambda { Puppet::Indirector::Request.new(:ind, :method, :key, nil) }.should_not raise_error(ArgumentError)
     end
 
     it "should use an empty options hash if nil was provided" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, nil).options.should == {}
+      Puppet::Indirector::Request.new(:ind, :method, :key, nil, nil).options.should == {}
     end
 
     it "should default to a nil node" do
@@ -49,7 +53,7 @@ describe Puppet::Indirector::Request do
     end
 
     it "should set its node attribute if provided in the options" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, :node => "foo.com").node.should == "foo.com"
+      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :node => "foo.com").node.should == "foo.com"
     end
 
     it "should default to a nil ip" do
@@ -57,7 +61,7 @@ describe Puppet::Indirector::Request do
     end
 
     it "should set its ip attribute if provided in the options" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, :ip => "192.168.0.1").ip.should == "192.168.0.1"
+      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ip => "192.168.0.1").ip.should == "192.168.0.1"
     end
 
     it "should default to being unauthenticated" do
@@ -65,23 +69,23 @@ describe Puppet::Indirector::Request do
     end
 
     it "should set be marked authenticated if configured in the options" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, :authenticated => "eh").should be_authenticated
+      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :authenticated => "eh").should 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, :node => "eh").options.should be_instance_of(Hash)
+      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :node => "eh").options.should 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, :foo => "bar").options.should be_instance_of(Hash)
+      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :foo => "bar").options.should 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, :server => "bar").options[:server].should == "bar"
+      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :server => "bar").options[:server].should == "bar"
     end
 
     it "should normalize options to use symbols as keys" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, "foo" => "bar").options[:foo].should == "bar"
+      Puppet::Indirector::Request.new(:ind, :method, :key, nil, "foo" => "bar").options[:foo].should == "bar"
     end
 
     describe "and the request key is a URI" do
@@ -89,7 +93,7 @@ describe Puppet::Indirector::Request do
 
       describe "and the URI is a 'file' URI" do
         before do
-          @request = Puppet::Indirector::Request.new(:ind, :method, "#{URI.unescape(Puppet::Util.path_to_uri(file).to_s)}")
+          @request = Puppet::Indirector::Request.new(:ind, :method, "#{URI.unescape(Puppet::Util.path_to_uri(file).to_s)}", nil)
         end
 
         it "should set the request key to the unescaped full file path" do
@@ -110,64 +114,64 @@ describe Puppet::Indirector::Request do
       end
 
       it "should set the protocol to the URI scheme" do
-        Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff").protocol.should == "http"
+        Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff", nil).protocol.should == "http"
       end
 
       it "should set the server if a server is provided" do
-        Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff").server.should == "host"
+        Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff", nil).server.should == "host"
       end
 
       it "should set the server and port if both are provided" do
-        Puppet::Indirector::Request.new(:ind, :method, "http://host:543/stuff").port.should == 543
+        Puppet::Indirector::Request.new(:ind, :method, "http://host:543/stuff", nil).port.should == 543
       end
 
       it "should default to the masterport if the URI scheme is 'puppet'" do
-        Puppet.settings.expects(:value).with(:masterport).returns "321"
-        Puppet::Indirector::Request.new(:ind, :method, "puppet://host/stuff").port.should == 321
+        Puppet[:masterport] = "321"
+        Puppet::Indirector::Request.new(:ind, :method, "puppet://host/stuff", nil).port.should == 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").port.should == 80
+        Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff", nil).port.should == 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").key.should == "stuff with spaces"
+        Puppet::Indirector::Request.new(:ind, :method, "http://host/environment/terminus/stuff with spaces", nil).key.should == "stuff with spaces"
       end
 
       it "should set the :uri attribute to the full URI" do
-        Puppet::Indirector::Request.new(:ind, :method, "http:///stu ff").uri.should == 'http:///stu ff'
+        Puppet::Indirector::Request.new(:ind, :method, "http:///stu ff", nil).uri.should == 'http:///stu ff'
       end
 
       it "should not parse relative URI" do
-        Puppet::Indirector::Request.new(:ind, :method, "foo/bar").uri.should be_nil
+        Puppet::Indirector::Request.new(:ind, :method, "foo/bar", nil).uri.should be_nil
       end
 
       it "should not parse opaque URI" do
-        Puppet::Indirector::Request.new(:ind, :method, "mailto:joe").uri.should be_nil
+        Puppet::Indirector::Request.new(:ind, :method, "mailto:joe", nil).uri.should be_nil
       end
     end
 
     it "should allow indication that it should not read a cached instance" do
-      Puppet::Indirector::Request.new(:ind, :method, :key, :ignore_cache => true).should be_ignore_cache
+      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ignore_cache => true).should be_ignore_cache
     end
 
     it "should default to not ignoring the cache" do
-      Puppet::Indirector::Request.new(:ind, :method, :key).should_not be_ignore_cache
+      Puppet::Indirector::Request.new(:ind, :method, :key, nil).should_not 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, :ignore_terminus => true).should be_ignore_terminus
+      Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ignore_terminus => true).should be_ignore_terminus
     end
 
     it "should default to not ignoring the terminus" do
-      Puppet::Indirector::Request.new(:ind, :method, :key).should_not be_ignore_terminus
+      Puppet::Indirector::Request.new(:ind, :method, :key, nil).should_not be_ignore_terminus
     end
   end
 
   it "should look use the Indirection class to return the appropriate indirection" do
     ind = mock 'indirection'
     Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
-    request = Puppet::Indirector::Request.new(:myind, :method, :key)
+    request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
     request.indirection.should equal(ind)
   end
@@ -175,7 +179,7 @@ describe Puppet::Indirector::Request do
   it "should use its indirection to look up the appropriate model" do
     ind = mock 'indirection'
     Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
-    request = Puppet::Indirector::Request.new(:myind, :method, :key)
+    request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
     ind.expects(:model).returns "mymodel"
 
@@ -184,63 +188,63 @@ describe Puppet::Indirector::Request do
 
   it "should fail intelligently when asked to find a model but the indirection cannot be found" do
     Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns nil
-    request = Puppet::Indirector::Request.new(:myind, :method, :key)
+    request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
     lambda { request.model }.should raise_error(ArgumentError)
   end
 
   it "should have a method for determining if the request is plural or singular" do
-    Puppet::Indirector::Request.new(:myind, :method, :key).should respond_to(:plural?)
+    Puppet::Indirector::Request.new(:myind, :method, :key, nil).should respond_to(:plural?)
   end
 
   it "should be considered plural if the method is 'search'" do
-    Puppet::Indirector::Request.new(:myind, :search, :key).should be_plural
+    Puppet::Indirector::Request.new(:myind, :search, :key, nil).should be_plural
   end
 
   it "should not be considered plural if the method is not 'search'" do
-    Puppet::Indirector::Request.new(:myind, :find, :key).should_not be_plural
+    Puppet::Indirector::Request.new(:myind, :find, :key, nil).should_not 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").to_s.should == "foo://bar/baz"
+    Puppet::Indirector::Request.new(:myind, :find, "foo://bar/baz", nil).to_s.should == "foo://bar/baz"
   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") == "/myind/key"
+    Puppet::Indirector::Request.new(:myind, :find, "key", nil) == "/myind/key"
   end
 
   it "should be able to return the URI-escaped key" do
-    Puppet::Indirector::Request.new(:myind, :find, "my key").escaped_key.should == URI.escape("my key")
+    Puppet::Indirector::Request.new(:myind, :find, "my key", nil).escaped_key.should == URI.escape("my key")
   end
 
   it "should have an environment accessor" do
-    Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => "foo").should respond_to(:environment)
+    Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => "foo").should respond_to(:environment)
   end
 
   it "should set its environment to an environment instance when a string is specified as its environment" do
-    Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => "foo").environment.should == Puppet::Node::Environment.new("foo")
+    Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => "foo").environment.should == Puppet::Node::Environment.new("foo")
   end
 
   it "should use any passed in environment instances as its environment" do
     env = Puppet::Node::Environment.new("foo")
-    Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => env).environment.should equal(env)
+    Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => env).environment.should equal(env)
   end
 
   it "should use the default environment when none is provided" do
-    Puppet::Indirector::Request.new(:myind, :find, "my key" ).environment.should equal(Puppet::Node::Environment.new)
+    Puppet::Indirector::Request.new(:myind, :find, "my key", nil ).environment.should equal(Puppet::Node::Environment.new)
   end
 
   it "should support converting its options to a hash" do
-    Puppet::Indirector::Request.new(:myind, :find, "my key" ).should respond_to(:to_hash)
+    Puppet::Indirector::Request.new(:myind, :find, "my key", nil ).should 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", :node => 'foo').to_hash[:node].should == 'foo'
+    Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :node => 'foo').to_hash[:node].should == 'foo'
   end
 
   describe "when building a query string from its options" do
     before do
-      @request = Puppet::Indirector::Request.new(:myind, :find, "my key")
+      @request = Puppet::Indirector::Request.new(:myind, :find, "my key", nil)
     end
 
     it "should return an empty query string if there are no options" do
@@ -312,25 +316,198 @@ describe Puppet::Indirector::Request do
     end
   end
 
-  describe "#remote?" do
-    def request(options = {})
-      Puppet::Indirector::Request.new('node', 'find', 'localhost', options)
+  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")
+      lambda { from_json(json.to_pson) }.should 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")
+      lambda { from_json(json.to_pson) }.should raise_error(ArgumentError)
     end
 
-    it "should not be unless node or ip is set" do
-      request.should_not be_remote
+    it "should set its method" do
+      from_json(@request.to_pson).method.should == "find"
     end
 
-    it "should be remote if node is set" do
-      request(:node => 'example.com').should be_remote
+    it "should fail if no method is provided" do
+      json = PSON.parse(@request.to_pson)
+      json['data'].delete("method")
+      lambda { from_json(json.to_pson) }.should raise_error(ArgumentError)
     end
 
-    it "should be remote if ip is set" do
-      request(:ip => '127.0.0.1').should be_remote
+    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 be remote if node and ip are set" do
-      request(:node => 'example.com', :ip => '127.0.0.1').should be_remote
+    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)
+    end
+
+    context 'when not using SRV records' do
+      before :each do
+        Puppet.settings[:use_srv_records] = false
+      end
+
+      it "yields the request with the default server and port when no server or port were specified on the original 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'
+          'Block return value'
+        end
+        count.should == 1
+
+        rval.should == 'Block return value'
+      end
+    end
+
+    context 'when using SRV records' do
+      before :each do
+        Puppet.settings[:use_srv_records] = true
+        Puppet.settings[:srv_domain]      = 'example.com'
+      end
+
+      it "yields the request with the original server and port unmodified" do
+        @request.server = 'puppet.example.com'
+        @request.port   = '90210'
+
+        count = 0
+        rval = @request.do_request do |got|
+          count += 1
+          got.server.should == 'puppet.example.com'
+          got.port.should   == '90210'
+          'Block return value'
+        end
+        count.should == 1
+
+        rval.should == 'Block return value'
+      end
+
+      context "when SRV returns servers" do
+        before :each do
+          @dns_mock = mock('dns')
+          Resolv::DNS.expects(:new).returns(@dns_mock)
+
+          @port = 7205
+          @host = '_x-puppet._tcp.example.com'
+          @srv_records = [Resolv::DNS::Resource::IN::SRV.new(0, 0, @port, @host)]
+
+          @dns_mock.expects(:getresources).
+            with("_x-puppet._tcp.#{Puppet.settings[:srv_domain]}", Resolv::DNS::Resource::IN::SRV).
+            returns(@srv_records)
+        end
+
+        it "yields a request using the server and port from the SRV record" do
+          count = 0
+          rval = @request.do_request do |got|
+            count += 1
+            got.server.should == '_x-puppet._tcp.example.com'
+            got.port.should == 7205
+
+            @block_return
+          end
+          count.should == 1
+
+          rval.should == @block_return
+        end
+
+        it "should fall back to the default server when the block raises a SystemCallError" do
+          count = 0
+          second_pass = nil
+
+          rval = @request.do_request(:puppet, 'puppet', 8140) do |got|
+            count += 1
+
+            if got.server == '_x-puppet._tcp.example.com' then
+              raise SystemCallError, "example failure"
+            else
+              second_pass = got
+            end
+
+            @block_return
+          end
+
+          second_pass.server.should == 'puppet'
+          second_pass.port.should   == 8140
+          count.should == 2
+
+          rval.should == @block_return
+        end
+      end
     end
   end
 end