[Pkg-puppet-devel] [SCM] Puppet packaging for Debian branch, experimental, updated. debian/2.6.8-1-844-g7ec39d5
Jesse Wolfe
jes5199 at gmail.com
Tue May 10 07:59:51 UTC 2011
The following commit has been merged in the experimental branch:
commit cfe202539018b27c35ff833152f237bc30569a5f
Author: Jesse Wolfe <jes5199 at gmail.com>
Date: Mon Nov 1 18:03:02 2010 -0700
Maint: Remove Indirector::Request objects from HTTP Handler and API V1
This is a maintenance refactor to reduce the dependencies between the
rest API and the implementation of the Indirector. The HTTP Handler code
was creating temporary Request objects that were not actually being
passed to the Indirector.
diff --git a/lib/puppet/network/http/api/v1.rb b/lib/puppet/network/http/api/v1.rb
index 2a47363..abbb2df 100644
--- a/lib/puppet/network/http/api/v1.rb
+++ b/lib/puppet/network/http/api/v1.rb
@@ -30,7 +30,7 @@ module Puppet::Network::HTTP::API::V1
key = URI.unescape(key)
- Puppet::Indirector::Request.new(indirection, method, key, params)
+ [indirection, method, key, params]
end
def indirection2uri(request)
diff --git a/lib/puppet/network/http/handler.rb b/lib/puppet/network/http/handler.rb
index e5aa1c5..82238aa 100644
--- a/lib/puppet/network/http/handler.rb
+++ b/lib/puppet/network/http/handler.rb
@@ -61,11 +61,11 @@ module Puppet::Network::HTTP::Handler
# handle an HTTP request
def process(request, response)
- indirection_request = uri2indirection(http_method(request), path(request), params(request))
+ indirection, method, key, params = uri2indirection(http_method(request), path(request), params(request))
- check_authorization(indirection_request)
+ check_authorization(indirection, method, key, params)
- send("do_#{indirection_request.method}", indirection_request, request, response)
+ send("do_#{method}", indirection, key, params, request, response)
rescue SystemExit,NoMemoryError
raise
rescue Exception => e
@@ -96,11 +96,16 @@ module Puppet::Network::HTTP::Handler
set_response(response, exception.to_s, status)
end
+ def model(indirection_name)
+ raise ArgumentError, "Could not find indirection '#{indirection_name}'" unless indirection = Puppet::Indirector::Indirection.instance(indirection_name.to_sym)
+ indirection.model
+ end
+
# Execute our find.
- def do_find(indirection_request, request, response)
- unless result = indirection_request.model.find(indirection_request.key, indirection_request.to_hash)
- Puppet.info("Could not find #{indirection_request.indirection_name} for '#{indirection_request.key}'")
- return do_exception(response, "Could not find #{indirection_request.indirection_name} #{indirection_request.key}", 404)
+ def do_find(indirection_name, key, params, request, response)
+ unless result = model(indirection_name).find(key, params)
+ Puppet.info("Could not find #{indirection_name} for '#{key}'")
+ return do_exception(response, "Could not find #{indirection_name} #{key}", 404)
end
# The encoding of the result must include the format to use,
@@ -113,34 +118,35 @@ module Puppet::Network::HTTP::Handler
end
# Execute our search.
- def do_search(indirection_request, request, response)
- result = indirection_request.model.search(indirection_request.key, indirection_request.to_hash)
+ def do_search(indirection_name, key, params, request, response)
+ model = self.model(indirection_name)
+ result = model.search(key, params)
if result.nil?
- return do_exception(response, "Could not find instances in #{indirection_request.indirection_name} with '#{indirection_request.key}'", 404)
+ return do_exception(response, "Could not find instances in #{indirection_name} with '#{key}'", 404)
end
format = format_to_use(request)
set_content_type(response, format)
- set_response(response, indirection_request.model.render_multiple(format, result))
+ set_response(response, model.render_multiple(format, result))
end
# Execute our destroy.
- def do_destroy(indirection_request, request, response)
- result = indirection_request.model.destroy(indirection_request.key, indirection_request.to_hash)
+ def do_destroy(indirection_name, key, params, request, response)
+ result = model(indirection_name).destroy(key, params)
return_yaml_response(response, result)
end
# Execute our save.
- def do_save(indirection_request, request, response)
+ def do_save(indirection_name, key, params, request, response)
data = body(request).to_s
raise ArgumentError, "No data to save" if !data or data.empty?
format = request_format(request)
- obj = indirection_request.model.convert_from(format, data)
- result = save_object(indirection_request, obj)
+ obj = model(indirection_name).convert_from(format, data)
+ result = obj.save(key)
return_yaml_response(response, result)
end
@@ -162,12 +168,6 @@ module Puppet::Network::HTTP::Handler
set_response(response, body.to_yaml)
end
- # LAK:NOTE This has to be here for testing; it's a stub-point so
- # we keep infinite recursion from happening.
- def save_object(ind_request, object)
- object.save(ind_request.key)
- end
-
def get?(request)
http_method(request) == 'GET'
end
diff --git a/lib/puppet/network/rest_authconfig.rb b/lib/puppet/network/rest_authconfig.rb
index 82d5a9d..b6a1633 100644
--- a/lib/puppet/network/rest_authconfig.rb
+++ b/lib/puppet/network/rest_authconfig.rb
@@ -32,21 +32,21 @@ module Puppet
# check wether this request is allowed in our ACL
# raise an Puppet::Network::AuthorizedError if the request
# is denied.
- def allowed?(request)
+ def allowed?(indirection, method, key, params)
read
# we're splitting the request in part because
# fail_on_deny could as well be called in the XMLRPC context
# with a ClientRequest.
- @rights.fail_on_deny(
- build_uri(request),
-
- :node => request.node,
- :ip => request.ip,
- :method => request.method,
- :environment => request.environment,
- :authenticated => request.authenticated)
+ @rights.fail_on_deny(
+ build_uri(indirection, key),
+ :node => params[:node],
+ :ip => params[:ip],
+ :method => method,
+ :environment => params[:environment],
+ :authenticated => params[:authenticated]
+ )
end
def initialize(file = nil, parsenow = true)
@@ -90,8 +90,8 @@ module Puppet
@rights.restrict_authenticated(acl[:acl], acl[:authenticated]) unless acl[:authenticated].nil?
end
- def build_uri(request)
- "/#{request.indirection_name}/#{request.key}"
+ def build_uri(indirection_name, key)
+ "/#{indirection_name}/#{key}"
end
end
end
diff --git a/lib/puppet/network/rest_authorization.rb b/lib/puppet/network/rest_authorization.rb
index e052245..50f094e 100644
--- a/lib/puppet/network/rest_authorization.rb
+++ b/lib/puppet/network/rest_authorization.rb
@@ -15,8 +15,8 @@ module Puppet::Network
end
# Verify that our client has access.
- def check_authorization(request)
- authconfig.allowed?(request)
+ def check_authorization(indirection, method, key, params)
+ authconfig.allowed?(indirection, method, key, params)
end
end
end
diff --git a/spec/integration/indirector/bucket_file/rest_spec.rb b/spec/integration/indirector/bucket_file/rest_spec.rb
deleted file mode 100644
index dc10faa..0000000
--- a/spec/integration/indirector/bucket_file/rest_spec.rb
+++ /dev/null
@@ -1,69 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-
-require 'puppet/file_bucket/file'
-require 'puppet/network/server'
-require 'puppet/network/http/webrick/rest'
-
-describe "Filebucket REST Terminus" do
- before do
- Puppet[:masterport] = 34343
- Puppet[:server] = "localhost"
-
- # Get a safe temporary file
- @tmpfile = Tempfile.new("webrick_integration_testing")
- @dir = @tmpfile.path + "_dir"
-
- Puppet.settings[:confdir] = @dir
- Puppet.settings[:vardir] = @dir
- Puppet.settings[:group] = Process.gid
- Puppet.settings[:server] = "127.0.0.1"
- Puppet.settings[:masterport] = "34343"
-
- Puppet::Util::Cacher.expire
-
- Puppet[:servertype] = 'webrick'
- Puppet[:server] = '127.0.0.1'
- Puppet[:certname] = '127.0.0.1'
-
- # Generate the certificate with a local CA
- Puppet::SSL::Host.ca_location = :local
- ca = Puppet::SSL::CertificateAuthority.new
- ca.generate(Puppet[:certname]) unless Puppet::SSL::Certificate.find(Puppet[:certname])
- ca.generate("foo.madstop.com") unless Puppet::SSL::Certificate.find(Puppet[:certname])
-
- @host = Puppet::SSL::Host.new(Puppet[:certname])
-
- @params = { :port => 34343, :handlers => [ :file_bucket_file ] }
- @server = Puppet::Network::Server.new(@params)
- @server.listen
-
- @old_terminus = Puppet::FileBucket::File.indirection.terminus_class
- Puppet::FileBucket::File.terminus_class = :rest
-
- # LAK:NOTE We need to have a fake model here so that our indirected methods get
- # passed through REST; otherwise we'd be stubbing 'find', which would cause an immediate
- # return.
- @file_bucket_file = stub_everything 'file_bucket_file'
- @mock_model = stub('faked model', :name => "file_bucket_file", :convert_from => @file_bucket_file)
- Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
-
- Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:check_authorization)
- end
-
- after do
- Puppet::Network::HttpPool.expire
- Puppet::SSL::Host.ca_location = :none
- Puppet.settings.clear
- @server.unlisten
- Puppet::FileBucket::File.terminus_class = @old_terminus
- end
-
- it "should be able save a file to the remote filebucket" do
- @file_bucket_file.expects(:save)
-
- file_bucket_file = Puppet::FileBucket::File.new("pouet")
- file_bucket_file.save
- end
-end
diff --git a/spec/integration/indirector/certificate/rest_spec.rb b/spec/integration/indirector/certificate/rest_spec.rb
deleted file mode 100755
index 58aa96c..0000000
--- a/spec/integration/indirector/certificate/rest_spec.rb
+++ /dev/null
@@ -1,69 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-
-require 'puppet/ssl/certificate'
-require 'puppet/network/server'
-require 'puppet/network/http/webrick/rest'
-
-describe "Certificate REST Terminus" do
- before do
- Puppet[:masterport] = 34343
- Puppet[:server] = "localhost"
-
- # Get a safe temporary file
- @tmpfile = Tempfile.new("webrick_integration_testing")
- @dir = @tmpfile.path + "_dir"
-
- Puppet.settings[:confdir] = @dir
- Puppet.settings[:vardir] = @dir
- Puppet.settings[:group] = Process.gid
- Puppet.settings[:server] = "127.0.0.1"
- Puppet.settings[:masterport] = "34343"
-
- Puppet::Util::Cacher.expire
-
- Puppet[:servertype] = 'webrick'
- Puppet[:server] = '127.0.0.1'
- Puppet[:certname] = '127.0.0.1'
-
- # Generate the certificate with a local CA
- Puppet::SSL::Host.ca_location = :local
- ca = Puppet::SSL::CertificateAuthority.new
- ca.generate(Puppet[:certname]) unless Puppet::SSL::Certificate.find(Puppet[:certname])
- ca.generate("foo.madstop.com") unless Puppet::SSL::Certificate.find(Puppet[:certname])
-
- @host = Puppet::SSL::Host.new(Puppet[:certname])
-
- @params = { :port => 34343, :handlers => [ :certificate ] }
- @server = Puppet::Network::Server.new(@params)
- @server.listen
-
- # Then switch to a remote CA, so that we go through REST.
- Puppet::SSL::Host.ca_location = :remote
-
- # LAK:NOTE We need to have a fake model here so that our indirected methods get
- # passed through REST; otherwise we'd be stubbing 'find', which would cause an immediate
- # return.
- @mock_model = stub('faked model', :name => "certificate")
- Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
-
- Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:check_authorization).returns(true)
- end
-
- after do
- Puppet::Network::HttpPool.expire
- Puppet::SSL::Host.ca_location = :none
- Puppet.settings.clear
- @server.unlisten
- end
-
- it "should be able to retrieve a remote certificate" do
- @mock_model.expects(:find).returns @host.certificate
- result = Puppet::SSL::Certificate.find('bar')
-
- # There's no good '==' method on certs.
- result.content.to_s.should == @host.certificate.content.to_s
- result.name.should == "bar"
- end
-end
diff --git a/spec/integration/indirector/certificate_request/rest_spec.rb b/spec/integration/indirector/certificate_request/rest_spec.rb
deleted file mode 100755
index c718b78..0000000
--- a/spec/integration/indirector/certificate_request/rest_spec.rb
+++ /dev/null
@@ -1,89 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-
-require 'puppet/ssl/certificate_request'
-require 'puppet/network/server'
-require 'puppet/network/http/webrick/rest'
-
-describe "Certificate Request REST Terminus" do
- before do
- Puppet::Util::Cacher.expire
-
- Puppet[:masterport] = 34343
- Puppet[:server] = "localhost"
-
- # Get a safe temporary file
- @tmpfile = Tempfile.new("webrick_integration_testing")
- @dir = @tmpfile.path + "_dir"
-
- Puppet.settings[:confdir] = @dir
- Puppet.settings[:vardir] = @dir
- Puppet.settings[:group] = Process.gid
- Puppet.settings[:server] = "127.0.0.1"
- Puppet.settings[:masterport] = "34343"
-
- Puppet[:servertype] = 'webrick'
- Puppet[:server] = '127.0.0.1'
- Puppet[:certname] = '127.0.0.1'
-
- # Generate the certificate with a local CA
- Puppet::SSL::Host.ca_location = :local
- ca = Puppet::SSL::CertificateAuthority.new
- ca.generate(Puppet[:certname]) unless Puppet::SSL::Certificate.find(Puppet[:certname])
-
- # Create the CSR and write it to disk
- @host = Puppet::SSL::Host.new("foo.madstop.com")
- @host.generate_certificate_request
-
- # Now remove the cached csr
- Puppet::SSL::Host.ca_location = :none
- Puppet::SSL::Host.destroy("foo.madstop.com")
-
- @params = { :port => 34343, :handlers => [ :certificate_request ] }
- @server = Puppet::Network::Server.new(@params)
- @server.listen
-
- # Then switch to a remote CA, so that we go through REST.
- Puppet::SSL::Host.ca_location = :remote
-
- # LAK:NOTE We need to have a fake model here so that our indirected methods get
- # passed through REST; otherwise we'd be stubbing 'find', which would cause an immediate
- # return.
- @mock_model = stub('faked model', :name => "certificate request")
- Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
-
- Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:check_authorization).returns(true)
- end
-
- after do
- Puppet::Network::HttpPool.expire
- Puppet::SSL::Host.ca_location = :none
- Puppet.settings.clear
- @server.unlisten
- end
-
- it "should be able to save a certificate request to the CA" do
- key = Puppet::SSL::Key.new("bar.madstop.com")
- key.generate
-
- csr = Puppet::SSL::CertificateRequest.new("bar.madstop.com")
- csr.generate(key.content)
-
- server_csr = mock 'csr'
- server_csr.expects(:save)
- @mock_model.expects(:convert_from).with("s", csr.content.to_s).returns server_csr
-
- csr.save
- end
-
- it "should be able to retrieve a remote certificate request" do
- # We're finding the cached value :/
- @mock_model.expects(:find).returns @host.certificate_request
- result = Puppet::SSL::CertificateRequest.find('foo.madstop.com')
-
- # There's no good '==' method on certs.
- result.content.to_s.should == @host.certificate_request.content.to_s
- result.name.should == @host.certificate_request.name
- end
-end
diff --git a/spec/integration/indirector/certificate_revocation_list/rest_spec.rb b/spec/integration/indirector/certificate_revocation_list/rest_spec.rb
deleted file mode 100755
index d831805..0000000
--- a/spec/integration/indirector/certificate_revocation_list/rest_spec.rb
+++ /dev/null
@@ -1,81 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-
-require 'puppet/ssl/certificate'
-require 'puppet/network/server'
-require 'puppet/network/http/webrick/rest'
-
-describe "Certificate REST Terminus" do
- before do
-# This port randomization is NOT a good pattern for testing, don't copy
-# but it's a quick fix to deal with sporadic test failures in Hudson #4894
-# Ticket #5098 created to fix these tests in the future
- masterport = rand(100) + 34500
- Puppet[:masterport] = masterport
- Puppet[:server] = "localhost"
-
- # Get a safe temporary file
- @tmpfile = Tempfile.new("webrick_integration_testing")
- @dir = @tmpfile.path + "_dir"
-
- Puppet.settings[:confdir] = @dir
- Puppet.settings[:vardir] = @dir
- Puppet.settings[:group] = Process.gid
- Puppet.settings[:server] = "127.0.0.1"
- Puppet.settings[:masterport] = masterport
-
- Puppet::Util::Cacher.expire
-
- Puppet[:servertype] = 'webrick'
- Puppet[:server] = '127.0.0.1'
- Puppet[:certname] = '127.0.0.1'
-
- # Generate the certificate with a local CA
- Puppet::SSL::Host.ca_location = :local
- ca = Puppet::SSL::CertificateAuthority.new
- ca.generate(Puppet[:certname]) unless Puppet::SSL::Certificate.find(Puppet[:certname])
-
- @params = { :port => masterport, :handlers => [ :certificate_revocation_list ] }
- @server = Puppet::Network::Server.new(@params)
- @server.listen
-
- # And make sure we've generated the CRL
- @crl = ca.crl
-
- # Now remove the cached crl
- Puppet::SSL::Host.ca_location = :none
- Puppet::SSL::CertificateRevocationList.destroy(Puppet::SSL::CA_NAME)
-
- # This is necessary so that we create the SSL store before we start
- # using REST. This is necessary to prevent an infinite loop,
- # which only occurs during testing.
- Puppet::Network::HttpPool.ssl_host.ssl_store
-
- # Then switch to a remote CA, so that we go through REST.
- Puppet::SSL::Host.ca_location = :remote
-
- # LAK:NOTE We need to have a fake model here so that our indirected methods get
- # passed through REST; otherwise we'd be stubbing 'find', which would cause an immediate
- # return.
- @mock_model = stub('faked model', :name => "certificate")
- Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
-
- Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:check_authorization).returns(true)
- end
-
- after do
- Puppet::Network::HttpPool.expire
- Puppet::SSL::Host.ca_location = :none
- Puppet.settings.clear
- @server.unlisten
- end
-
- it "should be able to retrieve a remote CRL" do
- @mock_model.expects(:find).returns @crl
- result = Puppet::SSL::CertificateRevocationList.find('bar')
-
- # There's no good '==' method on certs.
- result.content.to_s.should == @crl.content.to_s
- end
-end
diff --git a/spec/integration/indirector/report/rest_spec.rb b/spec/integration/indirector/report/rest_spec.rb
deleted file mode 100644
index fdc2189..0000000
--- a/spec/integration/indirector/report/rest_spec.rb
+++ /dev/null
@@ -1,97 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-
-require 'puppet/transaction/report'
-require 'puppet/network/server'
-require 'puppet/network/http/webrick/rest'
-
-describe "Report REST Terminus" do
- before do
- Puppet[:masterport] = 34343
- Puppet[:server] = "localhost"
-
- # Get a safe temporary file
- @tmpfile = Tempfile.new("webrick_integration_testing")
- @dir = @tmpfile.path + "_dir"
-
- Puppet.settings[:confdir] = @dir
- Puppet.settings[:vardir] = @dir
- Puppet.settings[:group] = Process.gid
- Puppet.settings[:server] = "127.0.0.1"
- Puppet.settings[:masterport] = "34343"
-
- Puppet::Util::Cacher.expire
-
- Puppet[:servertype] = 'webrick'
- Puppet[:server] = '127.0.0.1'
- Puppet[:certname] = '127.0.0.1'
-
- # Generate the certificate with a local CA
- Puppet::SSL::Host.ca_location = :local
- ca = Puppet::SSL::CertificateAuthority.new
- ca.generate(Puppet[:certname]) unless Puppet::SSL::Certificate.find(Puppet[:certname])
- ca.generate("foo.madstop.com") unless Puppet::SSL::Certificate.find(Puppet[:certname])
-
- @host = Puppet::SSL::Host.new(Puppet[:certname])
-
- @params = { :port => 34343, :handlers => [ :report ] }
- @server = Puppet::Network::Server.new(@params)
- @server.listen
-
- # Let's use REST for our reports :-)
- @old_terminus = Puppet::Transaction::Report.indirection.terminus_class
- Puppet::Transaction::Report.terminus_class = :rest
-
- # LAK:NOTE We need to have a fake model here so that our indirected methods get
- # passed through REST; otherwise we'd be stubbing 'save', which would cause an immediate
- # return.
- @report = stub_everything 'report'
- @mock_model = stub_everything 'faked model', :name => "report", :convert_from => @report
- Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
-
- Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:check_authorization)
- end
-
- after do
- Puppet::Network::HttpPool.expire
- Puppet::SSL::Host.ca_location = :none
- Puppet.settings.clear
- @server.unlisten
- Puppet::Transaction::Report.terminus_class = @old_terminus
- end
-
- it "should be able to send a report to the server" do
- @report.expects(:save)
-
- report = Puppet::Transaction::Report.new
-
- resourcemetrics = {
- :total => 12,
- :out_of_sync => 20,
- :applied => 45,
- :skipped => 1,
- :restarted => 23,
- :failed_restarts => 1,
- :scheduled => 10
- }
- report.add_metric(:resources, resourcemetrics)
-
- timemetrics = {
- :resource1 => 10,
- :resource2 => 50,
- :resource3 => 40,
- :resource4 => 20,
- }
- report.add_metric(:times, timemetrics)
-
-
- report.add_metric(
- :changes,
-
- :total => 20
- )
-
- report.save
- end
-end
diff --git a/spec/integration/indirector/rest_spec.rb b/spec/integration/indirector/rest_spec.rb
deleted file mode 100755
index e36d793..0000000
--- a/spec/integration/indirector/rest_spec.rb
+++ /dev/null
@@ -1,529 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'puppet/network/server'
-require 'puppet/indirector'
-require 'puppet/indirector/rest'
-
-# a fake class that will be indirected via REST
-class Puppet::TestIndirectedFoo
- extend Puppet::Indirector
- indirects :test_indirected_foo, :terminus_setting => :test_indirected_foo_terminus
-
- attr_reader :value
- attr_accessor :name
-
- def initialize(value = 0)
- @value = value
- end
-
- def self.from_yaml(yaml)
- YAML.load(yaml)
- end
-
- def name
- "bob"
- end
-end
-
-# empty Terminus class -- this would normally have to be in a directory findable by the autoloader, but we short-circuit that below
-class Puppet::TestIndirectedFoo::Rest < Puppet::Indirector::REST
-end
-
-# This port randomization is NOT a good pattern for testing, don't copy
-# but it's a quick fix to deal with sporadic test failures in Hudson #4894
-# Ticket #5098 created to fix these tests in the future
-masterport = rand(100) + 34300
-
-describe Puppet::Indirector::REST do
- before do
- # Get a safe temporary file
- @tmpfile = Tempfile.new("webrick_integration_testing")
- @dir = @tmpfile.path + "_dir"
-
- Puppet.settings[:confdir] = @dir
- Puppet.settings[:vardir] = @dir
- Puppet.settings[:group] = Process.gid
- Puppet.settings[:server] = "127.0.0.1"
- Puppet.settings[:masterport] = masterport
-
- Puppet::SSL::Host.ca_location = :local
-
- Puppet::TestIndirectedFoo.terminus_class = :rest
- end
-
- after do
- Puppet::Network::HttpPool.expire
- Puppet::SSL::Host.ca_location = :none
- Puppet.settings.clear
- end
-
- describe "when using webrick" do
- before :each do
- Puppet::Util::Cacher.expire
-
- Puppet[:servertype] = 'webrick'
- Puppet[:server] = '127.0.0.1'
- Puppet[:certname] = '127.0.0.1'
-
- ca = Puppet::SSL::CertificateAuthority.new
- ca.generate(Puppet[:certname]) unless Puppet::SSL::Certificate.find(Puppet[:certname])
-
- @params = { :port => masterport, :handlers => [ :test_indirected_foo ], :xmlrpc_handlers => [ :status ] }
- @server = Puppet::Network::Server.new(@params)
- @server.listen
-
- # LAK:NOTE We need to have a fake model here so that our indirected methods get
- # passed through REST; otherwise we'd be stubbing 'find', which would cause an immediate
- # return.
- @mock_model = stub('faked model', :name => "foo")
- Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
-
- # do not trigger the authorization layer
- Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:check_authorization).returns(true)
- end
-
- describe "when finding a model instance over REST" do
- describe "when a matching model instance can be found" do
- before :each do
- @model_instance = Puppet::TestIndirectedFoo.new(23)
- @mock_model.stubs(:find).returns @model_instance
- end
-
- it "should not fail" do
- lambda { Puppet::TestIndirectedFoo.find('bar') }.should_not raise_error
- end
-
- it 'should return an instance of the model class' do
- Puppet::TestIndirectedFoo.find('bar').class.should == Puppet::TestIndirectedFoo
- end
-
- it "should pass options all the way through" do
- @mock_model.expects(:find).with { |key, args| args[:one] == "two" and args[:three] == "four" }.returns @model_instance
- Puppet::TestIndirectedFoo.find('bar', :one => "two", :three => "four")
- end
-
- it 'should return the instance of the model class associated with the provided lookup key' do
- Puppet::TestIndirectedFoo.find('bar').value.should == @model_instance.value
- end
-
- it 'should set an expiration on model instance' do
- Puppet::TestIndirectedFoo.find('bar').expiration.should_not be_nil
- end
-
- it "should use a supported format" do
- Puppet::TestIndirectedFoo.expects(:supported_formats).returns ["marshal"]
- text = Marshal.dump(@model_instance)
- @model_instance.expects(:render).with(Puppet::Network::FormatHandler.format("marshal")).returns text
- Puppet::TestIndirectedFoo.find('bar')
- end
- end
-
- describe "when no matching model instance can be found" do
- before :each do
- @mock_model = stub('faked model', :name => "foo", :find => nil)
- Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
- end
-
- it "should return nil" do
- Puppet::TestIndirectedFoo.find('bar').should be_nil
- end
- end
-
- describe "when an exception is encountered in looking up a model instance" do
- before :each do
- @mock_model = stub('faked model', :name => "foo")
- @mock_model.stubs(:find).raises(RuntimeError)
- Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
- end
-
- it "should raise an exception" do
- lambda { Puppet::TestIndirectedFoo.find('bar') }.should raise_error(Net::HTTPError)
- end
- end
- end
-
- describe "when searching for model instances over REST" do
- describe "when matching model instances can be found" do
- before :each do
- @model_instances = [ Puppet::TestIndirectedFoo.new(23), Puppet::TestIndirectedFoo.new(24) ]
- @mock_model.stubs(:search).returns @model_instances
-
- # Force yaml, because otherwise our mocks can't work correctly
- Puppet::TestIndirectedFoo.stubs(:supported_formats).returns %w{yaml}
-
- @mock_model.stubs(:render_multiple).returns @model_instances.to_yaml
- end
-
- it "should not fail" do
- lambda { Puppet::TestIndirectedFoo.search('bar') }.should_not raise_error
- end
-
- it 'should return all matching results' do
- Puppet::TestIndirectedFoo.search('bar').length.should == @model_instances.length
- end
-
- it "should pass options all the way through" do
- @mock_model.expects(:search).with { |key, args| args[:one] == "two" and args[:three] == "four" }.returns @model_instances
- Puppet::TestIndirectedFoo.search("foo", :one => "two", :three => "four")
- end
-
- it 'should return model instances' do
- Puppet::TestIndirectedFoo.search('bar').each do |result|
- result.class.should == Puppet::TestIndirectedFoo
- end
- end
-
- it 'should return the instance of the model class associated with the provided lookup key' do
- Puppet::TestIndirectedFoo.search('bar').collect { |i| i.value }.should == @model_instances.collect { |i| i.value }
- end
- end
-
- describe "when no matching model instance can be found" do
- before :each do
- @mock_model = stub('faked model', :name => "foo", :find => nil)
- Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
- end
-
- it "should return nil" do
- Puppet::TestIndirectedFoo.find('bar').should be_nil
- end
- end
-
- describe "when an exception is encountered in looking up a model instance" do
- before :each do
- @mock_model = stub('faked model')
- @mock_model.stubs(:find).raises(RuntimeError)
- Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
- end
-
- it "should raise an exception" do
- lambda { Puppet::TestIndirectedFoo.find('bar') }.should raise_error(Net::HTTPError)
- end
- end
- end
-
- describe "when destroying a model instance over REST" do
- describe "when a matching model instance can be found" do
- before :each do
- @mock_model.stubs(:destroy).returns true
- end
-
- it "should not fail" do
- lambda { Puppet::TestIndirectedFoo.destroy('bar') }.should_not raise_error
- end
-
- it 'should return success' do
- Puppet::TestIndirectedFoo.destroy('bar').should == true
- end
- end
-
- describe "when no matching model instance can be found" do
- before :each do
- @mock_model.stubs(:destroy).returns false
- end
-
- it "should return failure" do
- Puppet::TestIndirectedFoo.destroy('bar').should == false
- end
- end
-
- describe "when an exception is encountered in destroying a model instance" do
- before :each do
- @mock_model.stubs(:destroy).raises(RuntimeError)
- end
-
- it "should raise an exception" do
- lambda { Puppet::TestIndirectedFoo.destroy('bar') }.should raise_error(Net::HTTPError)
- end
- end
- end
-
- describe "when saving a model instance over REST" do
- before :each do
- @instance = Puppet::TestIndirectedFoo.new(42)
- @mock_model.stubs(:save_object).returns @instance
- @mock_model.stubs(:convert_from).returns @instance
- Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:save_object).returns(@instance)
- end
-
- describe "when a successful save can be performed" do
- before :each do
- end
-
- it "should not fail" do
- lambda { @instance.save }.should_not raise_error
- end
-
- it 'should return an instance of the model class' do
- @instance.save.class.should == Puppet::TestIndirectedFoo
- end
-
- it 'should return a matching instance of the model class' do
- @instance.save.value.should == @instance.value
- end
- end
-
- describe "when a save cannot be completed" do
- before :each do
- Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:save_object).returns(false)
- end
-
- it "should return failure" do
- @instance.save.should == false
- end
- end
-
- describe "when an exception is encountered in performing a save" do
- before :each do
- Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:save_object).raises(RuntimeError)
- end
-
- it "should raise an exception" do
- lambda { @instance.save }.should raise_error(Net::HTTPError)
- end
- end
- end
-
- after :each do
- @server.unlisten
- end
- end
-
- describe "when using mongrel" do
- confine "Mongrel is not available" => Puppet.features.mongrel?
-
- before :each do
- Puppet[:servertype] = 'mongrel'
- @params = { :port => masterport, :handlers => [ :test_indirected_foo ] }
-
- # Make sure we never get a cert, since mongrel can't speak ssl
- Puppet::SSL::Certificate.stubs(:find).returns nil
-
- # We stub ssl to be off, since mongrel can't speak ssl
- Net::HTTP.any_instance.stubs(:use_ssl?).returns false
-
- @server = Puppet::Network::Server.new(@params)
- @server.listen
-
- # LAK:NOTE We need to have a fake model here so that our indirected methods get
- # passed through REST; otherwise we'd be stubbing 'find', which would cause an immediate
- # return.
- @mock_model = stub('faked model', :name => "foo")
- Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
-
- # do not trigger the authorization layer
- Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:check_authorization).returns(true)
- end
-
- after :each do
- @server.unlisten
- end
-
- describe "when finding a model instance over REST" do
- describe "when a matching model instance can be found" do
- before :each do
- @model_instance = Puppet::TestIndirectedFoo.new(23)
- @mock_model.stubs(:find).returns @model_instance
- end
-
- it "should not fail" do
- lambda { Puppet::TestIndirectedFoo.find('bar') }.should_not raise_error
- end
-
- it 'should return an instance of the model class' do
- Puppet::TestIndirectedFoo.find('bar').class.should == Puppet::TestIndirectedFoo
- end
-
- it "should pass options all the way through" do
- @mock_model.expects(:find).with { |key, args| args[:one] == "two" and args[:three] == "four" }.returns @model_instance
- Puppet::TestIndirectedFoo.find('bar', :one => "two", :three => "four")
- end
-
- it 'should return the instance of the model class associated with the provided lookup key' do
- Puppet::TestIndirectedFoo.find('bar').value.should == @model_instance.value
- end
-
- it 'should set an expiration on model instance' do
- Puppet::TestIndirectedFoo.find('bar').expiration.should_not be_nil
- end
-
- it "should use a supported format" do
- Puppet::TestIndirectedFoo.expects(:supported_formats).returns ["marshal"]
- format = stub 'format'
- text = Marshal.dump(@model_instance)
- @model_instance.expects(:render).with(Puppet::Network::FormatHandler.format("marshal")).returns text
- Puppet::TestIndirectedFoo.find('bar')
- end
- end
-
- describe "when no matching model instance can be found" do
- before :each do
- @mock_model.stubs(:find).returns nil
- end
-
- it "should return nil" do
- Puppet::TestIndirectedFoo.find('bar').should be_nil
- end
- end
-
- describe "when an exception is encountered in looking up a model instance" do
- before :each do
- @mock_model.stubs(:find).raises(RuntimeError)
- end
-
- it "should raise an exception" do
- lambda { Puppet::TestIndirectedFoo.find('bar') }.should raise_error(Net::HTTPError)
- end
- end
- end
-
- describe "when searching for model instances over REST" do
- describe "when matching model instances can be found" do
- before :each do
- @model_instances = [ Puppet::TestIndirectedFoo.new(23), Puppet::TestIndirectedFoo.new(24) ]
-
- # Force yaml, because otherwise our mocks can't work correctly
- Puppet::TestIndirectedFoo.stubs(:supported_formats).returns %w{yaml}
-
- @mock_model.stubs(:search).returns @model_instances
- @mock_model.stubs(:render_multiple).returns @model_instances.to_yaml
- end
-
- it "should not fail" do
- lambda { Puppet::TestIndirectedFoo.search('bar') }.should_not raise_error
- end
-
- it 'should return all matching results' do
- Puppet::TestIndirectedFoo.search('bar').length.should == @model_instances.length
- end
-
- it "should pass options all the way through" do
- @mock_model.expects(:search).with { |key, args| args[:one] == "two" and args[:three] == "four" }.returns @model_instances
- Puppet::TestIndirectedFoo.search('bar', :one => "two", :three => "four")
- end
-
- it 'should return model instances' do
- Puppet::TestIndirectedFoo.search('bar').each do |result|
- result.class.should == Puppet::TestIndirectedFoo
- end
- end
-
- it 'should return the instance of the model class associated with the provided lookup key' do
- Puppet::TestIndirectedFoo.search('bar').collect { |i| i.value }.should == @model_instances.collect { |i| i.value }
- end
-
- it 'should set an expiration on model instances' do
- Puppet::TestIndirectedFoo.search('bar').each do |result|
- result.expiration.should_not be_nil
- end
- end
- end
-
- describe "when no matching model instance can be found" do
- before :each do
- @mock_model.stubs(:search).returns nil
- @mock_model.stubs(:render_multiple).returns nil.to_yaml
- end
-
- it "should return nil" do
- Puppet::TestIndirectedFoo.search('bar').should == []
- end
- end
-
- describe "when an exception is encountered in looking up a model instance" do
- before :each do
- @mock_model.stubs(:find).raises(RuntimeError)
- end
-
- it "should raise an exception" do
- lambda { Puppet::TestIndirectedFoo.find('bar') }.should raise_error(Net::HTTPError)
- end
- end
- end
-
- describe "when destroying a model instance over REST" do
- describe "when a matching model instance can be found" do
- before :each do
- @mock_model.stubs(:destroy).returns true
- end
-
- it "should not fail" do
- lambda { Puppet::TestIndirectedFoo.destroy('bar') }.should_not raise_error
- end
-
- it 'should return success' do
- Puppet::TestIndirectedFoo.destroy('bar').should == true
- end
- end
-
- describe "when no matching model instance can be found" do
- before :each do
- @mock_model.stubs(:destroy).returns false
- end
-
- it "should return failure" do
- Puppet::TestIndirectedFoo.destroy('bar').should == false
- end
- end
-
- describe "when an exception is encountered in destroying a model instance" do
- before :each do
- @mock_model.stubs(:destroy).raises(RuntimeError)
- end
-
- it "should raise an exception" do
- lambda { Puppet::TestIndirectedFoo.destroy('bar') }.should raise_error(Net::HTTPError)
- end
- end
- end
-
- describe "when saving a model instance over REST" do
- before :each do
- @instance = Puppet::TestIndirectedFoo.new(42)
- @mock_model.stubs(:convert_from).returns @instance
-
- # LAK:NOTE This stub is necessary to prevent the REST call from calling
- # REST.save again, thus producing painful infinite recursion.
- Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:save_object).returns(@instance)
- end
-
- describe "when a successful save can be performed" do
- before :each do
- end
-
- it "should not fail" do
- lambda { @instance.save }.should_not raise_error
- end
-
- it 'should return an instance of the model class' do
- @instance.save.class.should == Puppet::TestIndirectedFoo
- end
-
- it 'should return a matching instance of the model class' do
- @instance.save.value.should == @instance.value
- end
- end
-
- describe "when a save cannot be completed" do
- before :each do
- Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:save_object).returns(false)
- end
-
- it "should return failure" do
- @instance.save.should == false
- end
- end
-
- describe "when an exception is encountered in performing a save" do
- before :each do
- Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:save_object).raises(RuntimeError)
- end
-
- it "should raise an exception" do
- lambda { @instance.save }.should raise_error(Net::HTTPError)
- end
- end
- end
- end
-end
diff --git a/spec/unit/network/http/api/v1_spec.rb b/spec/unit/network/http/api/v1_spec.rb
index 8d50704..84b98dd 100644
--- a/spec/unit/network/http/api/v1_spec.rb
+++ b/spec/unit/network/http/api/v1_spec.rb
@@ -32,7 +32,7 @@ describe Puppet::Network::HTTP::API::V1 do
end
it "should use the first field of the URI as the environment" do
- @tester.uri2indirection("GET", "/env/foo/bar", {}).environment.should == Puppet::Node::Environment.new("env")
+ @tester.uri2indirection("GET", "/env/foo/bar", {})[3][:environment].should == "env"
end
it "should fail if the environment is not alphanumeric" do
@@ -40,11 +40,11 @@ describe Puppet::Network::HTTP::API::V1 do
end
it "should use the environment from the URI even if one is specified in the parameters" do
- @tester.uri2indirection("GET", "/env/foo/bar", {:environment => "otherenv"}).environment.should == Puppet::Node::Environment.new("env")
+ @tester.uri2indirection("GET", "/env/foo/bar", {:environment => "otherenv"})[3][:environment].should == "env"
end
it "should use the second field of the URI as the indirection name" do
- @tester.uri2indirection("GET", "/env/foo/bar", {}).indirection_name.should == :foo
+ @tester.uri2indirection("GET", "/env/foo/bar", {})[0].should == "foo"
end
it "should fail if the indirection name is not alphanumeric" do
@@ -52,11 +52,11 @@ describe Puppet::Network::HTTP::API::V1 do
end
it "should use the remainder of the URI as the indirection key" do
- @tester.uri2indirection("GET", "/env/foo/bar", {}).key.should == "bar"
+ @tester.uri2indirection("GET", "/env/foo/bar", {})[2].should == "bar"
end
it "should support the indirection key being a /-separated file path" do
- @tester.uri2indirection("GET", "/env/foo/bee/baz/bomb", {}).key.should == "bee/baz/bomb"
+ @tester.uri2indirection("GET", "/env/foo/bee/baz/bomb", {})[2].should == "bee/baz/bomb"
end
it "should fail if no indirection key is specified" do
@@ -65,31 +65,31 @@ describe Puppet::Network::HTTP::API::V1 do
end
it "should choose 'find' as the indirection method if the http method is a GET and the indirection name is singular" do
- @tester.uri2indirection("GET", "/env/foo/bar", {}).method.should == :find
+ @tester.uri2indirection("GET", "/env/foo/bar", {})[1].should == :find
end
it "should choose 'search' as the indirection method if the http method is a GET and the indirection name is plural" do
- @tester.uri2indirection("GET", "/env/foos/bar", {}).method.should == :search
+ @tester.uri2indirection("GET", "/env/foos/bar", {})[1].should == :search
end
it "should choose 'find' as the indirection method if the http method is a GET and the indirection name is facts" do
- @tester.uri2indirection("GET", "/env/facts/bar", {}).method.should == :find
+ @tester.uri2indirection("GET", "/env/facts/bar", {})[1].should == :find
end
it "should choose 'save' as the indirection method if the http method is a PUT and the indirection name is facts" do
- @tester.uri2indirection("PUT", "/env/facts/bar", {}).method.should == :save
+ @tester.uri2indirection("PUT", "/env/facts/bar", {})[1].should == :save
end
it "should choose 'search' as the indirection method if the http method is a GET and the indirection name is inventory" do
- @tester.uri2indirection("GET", "/env/inventory/search", {}).method.should == :search
+ @tester.uri2indirection("GET", "/env/inventory/search", {})[1].should == :search
end
it "should choose 'delete' as the indirection method if the http method is a DELETE and the indirection name is singular" do
- @tester.uri2indirection("DELETE", "/env/foo/bar", {}).method.should == :destroy
+ @tester.uri2indirection("DELETE", "/env/foo/bar", {})[1].should == :destroy
end
it "should choose 'save' as the indirection method if the http method is a PUT and the indirection name is singular" do
- @tester.uri2indirection("PUT", "/env/foo/bar", {}).method.should == :save
+ @tester.uri2indirection("PUT", "/env/foo/bar", {})[1].should == :save
end
it "should fail if an indirection method cannot be picked" do
@@ -98,7 +98,8 @@ describe Puppet::Network::HTTP::API::V1 do
it "should URI unescape the indirection key" do
escaped = URI.escape("foo bar")
- @tester.uri2indirection("GET", "/env/foo/#{escaped}", {}).key.should == "foo bar"
+ indirection_name, method, key, params = @tester.uri2indirection("GET", "/env/foo/#{escaped}", {})
+ key.should == "foo bar"
end
end
diff --git a/spec/unit/network/http/handler_spec.rb b/spec/unit/network/http/handler_spec.rb
index 355f500..16f1b53 100755
--- a/spec/unit/network/http/handler_spec.rb
+++ b/spec/unit/network/http/handler_spec.rb
@@ -79,37 +79,22 @@ describe Puppet::Network::HTTP::Handler do
@handler.process(@request, @response)
end
- it "should call the 'do' method associated with the indirection method" do
- request = stub 'request'
- @handler.expects(:uri2indirection).returns request
+ it "should call the 'do' method and delegate authorization to the RestAuthorization layer" do
+ @handler.expects(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
- request.expects(:method).returns "mymethod"
+ @handler.expects(:do_mymethod).with("facts", "key", {:node => "name"}, @request, @response)
- @handler.expects(:do_mymethod).with(request, @request, @response)
-
- @handler.process(@request, @response)
- end
-
- it "should delegate authorization to the RestAuthorization layer" do
- request = stub 'request'
- @handler.expects(:uri2indirection).returns request
-
- request.expects(:method).returns "mymethod"
-
- @handler.expects(:do_mymethod).with(request, @request, @response)
-
- @handler.expects(:check_authorization).with(request)
+ @handler.expects(:check_authorization).with("facts", :mymethod, "key", {:node => "name"})
@handler.process(@request, @response)
end
it "should return 403 if the request is not authorized" do
- request = stub 'request'
- @handler.expects(:uri2indirection).returns request
+ @handler.expects(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
@handler.expects(:do_mymethod).never
- @handler.expects(:check_authorization).with(request).raises(Puppet::Network::AuthorizationError.new("forbindden"))
+ @handler.expects(:check_authorization).with("facts", :mymethod, "key", {:node => "name"}).raises(Puppet::Network::AuthorizationError.new("forbidden"))
@handler.expects(:set_response).with { |response, body, status| status == 403 }
@@ -117,7 +102,7 @@ describe Puppet::Network::HTTP::Handler do
end
it "should serialize a controller exception when an exception is thrown while finding the model instance" do
- @handler.expects(:uri2indirection).returns stub("request", :method => :find)
+ @handler.expects(:uri2indirection).returns(["facts", :find, "key", {:node => "name"}])
@handler.expects(:do_find).raises(ArgumentError, "The exception")
@handler.expects(:set_response).with { |response, body, status| body == "The exception" and status == 400 }
@@ -141,9 +126,8 @@ describe Puppet::Network::HTTP::Handler do
describe "when finding a model instance" do
before do
- @irequest = stub 'indirection_request', :method => :find, :indirection_name => "my_handler", :to_hash => {}, :key => "my_result", :model => @model_class
-
@model_class.stubs(:find).returns @result
+ Puppet::Indirector::Indirection.expects(:instance).with(:my_handler).returns( stub "indirection", :model => @model_class )
@format = stub 'format', :suitable? => true, :mime => "text/format", :name => "format"
Puppet::Network::FormatHandler.stubs(:format).returns @format
@@ -153,40 +137,37 @@ describe Puppet::Network::HTTP::Handler do
end
it "should use the indirection request to find the model class" do
- @irequest.expects(:model).returns @model_class
-
- @handler.do_find(@irequest, @request, @response)
+ @handler.do_find("my_handler", "my_result", {}, @request, @response)
end
it "should use the escaped request key" do
@model_class.expects(:find).with do |key, args|
key == "my_result"
end.returns @result
- @handler.do_find(@irequest, @request, @response)
+ @handler.do_find("my_handler", "my_result", {}, @request, @response)
end
it "should use a common method for determining the request parameters" do
- @irequest.stubs(:to_hash).returns(:foo => :baz, :bar => :xyzzy)
@model_class.expects(:find).with do |key, args|
args[:foo] == :baz and args[:bar] == :xyzzy
end.returns @result
- @handler.do_find(@irequest, @request, @response)
+ @handler.do_find("my_handler", "my_result", {:foo => :baz, :bar => :xyzzy}, @request, @response)
end
it "should set the content type to the first format specified in the accept header" do
@handler.expects(:accept_header).with(@request).returns "one,two"
@handler.expects(:set_content_type).with(@response, @oneformat)
- @handler.do_find(@irequest, @request, @response)
+ @handler.do_find("my_handler", "my_result", {}, @request, @response)
end
it "should fail if no accept header is provided" do
@handler.expects(:accept_header).with(@request).returns nil
- lambda { @handler.do_find(@irequest, @request, @response) }.should raise_error(ArgumentError)
+ lambda { @handler.do_find("my_handler", "my_result", {}, @request, @response) }.should raise_error(ArgumentError)
end
it "should fail if the accept header does not contain a valid format" do
@handler.expects(:accept_header).with(@request).returns ""
- lambda { @handler.do_find(@irequest, @request, @response) }.should raise_error(RuntimeError)
+ lambda { @handler.do_find("my_handler", "my_result", {}, @request, @response) }.should raise_error(RuntimeError)
end
it "should not use an unsuitable format" do
@@ -198,7 +179,7 @@ describe Puppet::Network::HTTP::Handler do
@handler.expects(:set_content_type).with(@response, bar) # the suitable one
- @handler.do_find(@irequest, @request, @response)
+ @handler.do_find("my_handler", "my_result", {}, @request, @response)
end
it "should render the result using the first format specified in the accept header" do
@@ -206,12 +187,12 @@ describe Puppet::Network::HTTP::Handler do
@handler.expects(:accept_header).with(@request).returns "one,two"
@result.expects(:render).with(@oneformat)
- @handler.do_find(@irequest, @request, @response)
+ @handler.do_find("my_handler", "my_result", {}, @request, @response)
end
it "should use the default status when a model find call succeeds" do
@handler.expects(:set_response).with { |response, body, status| status.nil? }
- @handler.do_find(@irequest, @request, @response)
+ @handler.do_find("my_handler", "my_result", {}, @request, @response)
end
it "should return a serialized object when a model find call succeeds" do
@@ -220,14 +201,14 @@ describe Puppet::Network::HTTP::Handler do
@handler.expects(:set_response).with { |response, body, status| body == "my_rendered_object" }
@model_class.stubs(:find).returns(@model_instance)
- @handler.do_find(@irequest, @request, @response)
+ @handler.do_find("my_handler", "my_result", {}, @request, @response)
end
it "should return a 404 when no model instance can be found" do
@model_class.stubs(:name).returns "my name"
@handler.expects(:set_response).with { |response, body, status| status == 404 }
@model_class.stubs(:find).returns(nil)
- @handler.do_find(@irequest, @request, @response)
+ @handler.do_find("my_handler", "my_result", {}, @request, @response)
end
it "should write a log message when no model instance can be found" do
@@ -236,7 +217,7 @@ describe Puppet::Network::HTTP::Handler do
Puppet.expects(:info).with("Could not find my_handler for 'my_result'")
- @handler.do_find(@irequest, @request, @response)
+ @handler.do_find("my_handler", "my_result", {}, @request, @response)
end
@@ -246,13 +227,13 @@ describe Puppet::Network::HTTP::Handler do
@handler.expects(:format_to_use).returns(@oneformat)
@model_instance.expects(:render).with(@oneformat).returns "my_rendered_object"
@model_class.stubs(:find).returns(@model_instance)
- @handler.do_find(@irequest, @request, @response)
+ @handler.do_find("my_handler", "my_result", {}, @request, @response)
end
end
describe "when searching for model instances" do
before do
- @irequest = stub 'indirection_request', :method => :find, :indirection_name => "my_handler", :to_hash => {}, :key => "key", :model => @model_class
+ Puppet::Indirector::Indirection.expects(:instance).with(:my_handler).returns( stub "indirection", :model => @model_class )
@result1 = mock 'result1'
@result2 = mock 'results'
@@ -269,29 +250,26 @@ describe Puppet::Network::HTTP::Handler do
end
it "should use the indirection request to find the model" do
- @irequest.expects(:model).returns @model_class
-
- @handler.do_search(@irequest, @request, @response)
+ @handler.do_search("my_handler", "my_result", {}, @request, @response)
end
it "should use a common method for determining the request parameters" do
- @irequest.stubs(:to_hash).returns(:foo => :baz, :bar => :xyzzy)
@model_class.expects(:search).with do |key, args|
args[:foo] == :baz and args[:bar] == :xyzzy
end.returns @result
- @handler.do_search(@irequest, @request, @response)
+ @handler.do_search("my_handler", "my_result", {:foo => :baz, :bar => :xyzzy}, @request, @response)
end
it "should use the default status when a model search call succeeds" do
@model_class.stubs(:search).returns(@result)
- @handler.do_search(@irequest, @request, @response)
+ @handler.do_search("my_handler", "my_result", {}, @request, @response)
end
it "should set the content type to the first format returned by the accept header" do
@handler.expects(:accept_header).with(@request).returns "one,two"
@handler.expects(:set_content_type).with(@response, @oneformat)
- @handler.do_search(@irequest, @request, @response)
+ @handler.do_search("my_handler", "my_result", {}, @request, @response)
end
it "should return a list of serialized objects when a model search call succeeds" do
@@ -302,7 +280,7 @@ describe Puppet::Network::HTTP::Handler do
@model_class.expects(:render_multiple).with(@oneformat, @result).returns "my rendered instances"
@handler.expects(:set_response).with { |response, data| data == "my rendered instances" }
- @handler.do_search(@irequest, @request, @response)
+ @handler.do_search("my_handler", "my_result", {}, @request, @response)
end
it "should return [] when searching returns an empty array" do
@@ -312,50 +290,46 @@ describe Puppet::Network::HTTP::Handler do
@handler.expects(:set_response).with { |response, data| data == "[]" }
- @handler.do_search(@irequest, @request, @response)
+ @handler.do_search("my_handler", "my_result", {}, @request, @response)
end
it "should return a 404 when searching returns nil" do
@model_class.stubs(:name).returns "my name"
@handler.expects(:set_response).with { |response, body, status| status == 404 }
@model_class.stubs(:search).returns(nil)
- @handler.do_search(@irequest, @request, @response)
+ @handler.do_search("my_handler", "my_result", {}, @request, @response)
end
end
describe "when destroying a model instance" do
before do
- @irequest = stub 'indirection_request', :method => :destroy, :indirection_name => "my_handler", :to_hash => {}, :key => "key", :model => @model_class
+ Puppet::Indirector::Indirection.expects(:instance).with(:my_handler).returns( stub "indirection", :model => @model_class )
@result = stub 'result', :render => "the result"
@model_class.stubs(:destroy).returns @result
end
it "should use the indirection request to find the model" do
- @irequest.expects(:model).returns @model_class
-
- @handler.do_destroy(@irequest, @request, @response)
+ @handler.do_destroy("my_handler", "my_result", {}, @request, @response)
end
it "should use the escaped request key to destroy the instance in the model" do
- @irequest.expects(:key).returns "foo bar"
@model_class.expects(:destroy).with do |key, args|
key == "foo bar"
end
- @handler.do_destroy(@irequest, @request, @response)
+ @handler.do_destroy("my_handler", "foo bar", {}, @request, @response)
end
it "should use a common method for determining the request parameters" do
- @irequest.stubs(:to_hash).returns(:foo => :baz, :bar => :xyzzy)
@model_class.expects(:destroy).with do |key, args|
args[:foo] == :baz and args[:bar] == :xyzzy
end
- @handler.do_destroy(@irequest, @request, @response)
+ @handler.do_destroy("my_handler", "my_result", {:foo => :baz, :bar => :xyzzy}, @request, @response)
end
it "should use the default status code a model destroy call succeeds" do
@handler.expects(:set_response).with { |response, body, status| status.nil? }
- @handler.do_destroy(@irequest, @request, @response)
+ @handler.do_destroy("my_handler", "my_result", {}, @request, @response)
end
it "should return a yaml-encoded result when a model destroy call succeeds" do
@@ -364,13 +338,13 @@ describe Puppet::Network::HTTP::Handler do
@handler.expects(:set_response).with { |response, body, status| body == "the result" }
- @handler.do_destroy(@irequest, @request, @response)
+ @handler.do_destroy("my_handler", "my_result", {}, @request, @response)
end
end
describe "when saving a model instance" do
before do
- @irequest = stub 'indirection_request', :method => :save, :indirection_name => "my_handler", :to_hash => {}, :key => "key", :model => @model_class
+ Puppet::Indirector::Indirection.stubs(:instance).with(:my_handler).returns( stub "indirection", :model => @model_class )
@handler.stubs(:body).returns('my stuff')
@handler.stubs(:content_type_header).returns("text/yaml")
@@ -386,43 +360,41 @@ describe Puppet::Network::HTTP::Handler do
end
it "should use the indirection request to find the model" do
- @irequest.expects(:model).returns @model_class
-
- @handler.do_save(@irequest, @request, @response)
+ @handler.do_save("my_handler", "my_result", {}, @request, @response)
end
it "should use the 'body' hook to retrieve the body of the request" do
@handler.expects(:body).returns "my body"
@model_class.expects(:convert_from).with { |format, body| body == "my body" }.returns @model_instance
- @handler.do_save(@irequest, @request, @response)
+ @handler.do_save("my_handler", "my_result", {}, @request, @response)
end
it "should fail to save model if data is not specified" do
@handler.stubs(:body).returns('')
- lambda { @handler.do_save(@irequest, @request, @response) }.should raise_error(ArgumentError)
+ lambda { @handler.do_save("my_handler", "my_result", {}, @request, @response) }.should raise_error(ArgumentError)
end
it "should use a common method for determining the request parameters" do
@model_instance.expects(:save).with('key').once
- @handler.do_save(@irequest, @request, @response)
+ @handler.do_save("my_handler", "key", {}, @request, @response)
end
it "should use the default status when a model save call succeeds" do
@handler.expects(:set_response).with { |response, body, status| status.nil? }
- @handler.do_save(@irequest, @request, @response)
+ @handler.do_save("my_handler", "my_result", {}, @request, @response)
end
it "should return the yaml-serialized result when a model save call succeeds" do
@model_instance.stubs(:save).returns(@model_instance)
@model_instance.expects(:to_yaml).returns('foo')
- @handler.do_save(@irequest, @request, @response)
+ @handler.do_save("my_handler", "my_result", {}, @request, @response)
end
it "should set the content to yaml" do
@handler.expects(:set_content_type).with(@response, @yamlformat)
- @handler.do_save(@irequest, @request, @response)
+ @handler.do_save("my_handler", "my_result", {}, @request, @response)
end
it "should use the content-type header to know the body format" do
@@ -431,7 +403,7 @@ describe Puppet::Network::HTTP::Handler do
@model_class.expects(:convert_from).with { |format, body| format == "format" }.returns @model_instance
- @handler.do_save(@irequest, @request, @response)
+ @handler.do_save("my_handler", "my_result", {}, @request, @response)
end
end
end
diff --git a/spec/unit/network/rest_authconfig_spec.rb b/spec/unit/network/rest_authconfig_spec.rb
index 351f3f0..e81eb41 100755
--- a/spec/unit/network/rest_authconfig_spec.rb
+++ b/spec/unit/network/rest_authconfig_spec.rb
@@ -30,9 +30,6 @@ describe Puppet::Network::RestAuthConfig do
@acl = stub_everything 'rights'
@authconfig.rights = @acl
-
- @request = stub 'request', :indirection_name => "path", :key => "to/resource", :ip => "127.0.0.1",
- :node => "me", :method => :save, :environment => :env, :authenticated => true
end
it "should use the puppet default rest authorization file" do
@@ -41,16 +38,10 @@ describe Puppet::Network::RestAuthConfig do
Puppet::Network::RestAuthConfig.new(nil, false)
end
- it "should read the config file when needed" do
- @authconfig.expects(:read)
-
- @authconfig.allowed?(@request)
- end
-
it "should ask for authorization to the ACL subsystem" do
@acl.expects(:fail_on_deny).with("/path/to/resource", :node => "me", :ip => "127.0.0.1", :method => :save, :environment => :env, :authenticated => true)
- @authconfig.allowed?(@request)
+ @authconfig.allowed?("path", :save, "to/resource", :ip => "127.0.0.1", :node => "me", :environment => :env, :authenticated => true)
end
describe "when defining an acl with mk_acl" do
diff --git a/spec/unit/network/rest_authorization_spec.rb b/spec/unit/network/rest_authorization_spec.rb
deleted file mode 100755
index 0cb0bce..0000000
--- a/spec/unit/network/rest_authorization_spec.rb
+++ /dev/null
@@ -1,43 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/network/rest_authorization'
-
-class RestAuthorized
- include Puppet::Network::RestAuthorization
-end
-
-
-describe Puppet::Network::RestAuthorization do
- before :each do
- @auth = RestAuthorized.new
- @authconig = stub 'authconfig'
- @auth.stubs(:authconfig).returns(@authconfig)
-
- @request = stub_everything 'request'
- @request.stubs(:method).returns(:find)
- @request.stubs(:node).returns("node")
- @request.stubs(:ip).returns("ip")
- end
-
- describe "when testing request authorization" do
- it "should delegate to the current rest authconfig" do
- @authconfig.expects(:allowed?).with(@request).returns(true)
-
- @auth.check_authorization(@request)
- end
-
- it "should raise an AuthorizationError if authconfig raises an AuthorizationError" do
- @authconfig.expects(:allowed?).with(@request).raises(Puppet::Network::AuthorizationError.new("forbidden"))
-
- lambda { @auth.check_authorization(@request) }.should raise_error(Puppet::Network::AuthorizationError)
- end
-
- it "should not raise an AuthorizationError if request is allowed" do
- @authconfig.expects(:allowed?).with(@request).returns(true)
-
- lambda { @auth.check_authorization(@request) }.should_not raise_error(Puppet::Network::AuthorizationError)
- end
- end
-end
--
Puppet packaging for Debian
More information about the Pkg-puppet-devel
mailing list