puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

data/spec/unit/network/http/rack/rest_spec.rb

@@ -1,322 +0,0 @@
-require 'spec_helper'
-require 'puppet/network/http/rack' if Puppet.features.rack?
-require 'puppet/network/http/rack/rest'
-
-describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
-  it "should include the Puppet::Network::HTTP::Handler module" do
-    expect(Puppet::Network::HTTP::RackREST.ancestors).to be_include(Puppet::Network::HTTP::Handler)
-  end
-
-  describe "when serving a request" do
-    before :each do
-      @model_class = double('indirected model class')
-      allow(Puppet::Indirector::Indirection).to receive(:model).with(:foo).and_return(@model_class)
-
-      @response = Rack::Response.new
-      @handler = Puppet::Network::HTTP::RackREST.new(:handler => :foo)
-    end
-
-    def mk_req(uri, opts = {})
-      env = Rack::MockRequest.env_for(uri, opts)
-      Rack::Request.new(env)
-    end
-
-    let(:minimal_certificate) do
-      key = OpenSSL::PKey::RSA.new(512)
-      signer = Puppet::SSL::CertificateSigner.new
-      cert = OpenSSL::X509::Certificate.new
-      cert.version = 2
-      cert.serial = 0
-      cert.not_before = Time.now
-      cert.not_after = Time.now + 3600
-      cert.public_key = key
-      cert.subject = OpenSSL::X509::Name.parse("/CN=testing")
-      signer.sign(cert, key)
-      cert
-    end
-
-    describe "#headers" do
-      it "should return the headers (parsed from env with prefix 'HTTP_')" do
-        req = mk_req('/', {'HTTP_Accept' => 'myaccept',
-                           'HTTP_X_Custom_Header' => 'mycustom',
-                           'NOT_HTTP_foo' => 'not an http header'})
-        expect(@handler.headers(req)).to eq({"accept" => 'myaccept',
-                                         "x-custom-header" => 'mycustom',
-                                         "content-type" => nil })
-      end
-    end
-
-    describe "and using the HTTP Handler interface" do
-      it "should return the CONTENT_TYPE parameter as the content type header" do
-        req = mk_req('/', 'CONTENT_TYPE' => 'mycontent')
-        expect(@handler.headers(req)['content-type']).to eq("mycontent")
-      end
-
-      it "should use the REQUEST_METHOD as the http method" do
-        req = mk_req('/', :method => 'MYMETHOD')
-        expect(@handler.http_method(req)).to eq("MYMETHOD")
-      end
-
-      it "should return the request path as the path" do
-        req = mk_req('/foo/bar')
-        expect(@handler.path(req)).to eq("/foo/bar")
-      end
-
-      it "should return the unescaped path for an escaped request path" do
-        unescaped_path = '/foo/bar baz'
-        escaped_path = Puppet::Util.uri_encode(unescaped_path)
-        req = mk_req(escaped_path)
-        expect(@handler.path(req)).to eq(unescaped_path)
-      end
-
-      it "should return the request body as the body" do
-        req = mk_req('/foo/bar', :input => 'mybody')
-        expect(@handler.body(req)).to eq("mybody")
-      end
-
-      it "should return the an Puppet::SSL::Certificate instance as the client_cert" do
-        req = mk_req('/foo/bar', 'SSL_CLIENT_CERT' => minimal_certificate.to_pem)
-        expect(@handler.client_cert(req).content.to_pem).to eq(minimal_certificate.to_pem)
-      end
-
-      it "returns nil when SSL_CLIENT_CERT is empty" do
-        req = mk_req('/foo/bar', 'SSL_CLIENT_CERT' => '')
-
-        expect(@handler.client_cert(req)).to be_nil
-      end
-
-      it "should set the response's content-type header when setting the content type" do
-        @header = double('header')
-        expect(@response).to receive(:header).and_return(@header)
-        expect(@header).to receive(:[]=).with('Content-Type', "mytype")
-
-        @handler.set_content_type(@response, "mytype")
-      end
-
-      it "should set the status and write the body when setting the response for a request" do
-        expect(@response).to receive(:status=).with(400)
-        expect(@response).to receive(:write).with("mybody")
-
-        @handler.set_response(@response, "mybody", 400)
-      end
-
-      describe "when result is a File" do
-        before :each do
-          stat = double('stat', :size => 100)
-          @file = double('file', :stat => stat, :path => "/tmp/path")
-          allow(@file).to receive(:is_a?).with(File).and_return(true)
-        end
-
-        it "should set the Content-Length header as a string" do
-          expect(@response).to receive(:[]=).with("Content-Length", '100')
-
-          @handler.set_response(@response, @file, 200)
-        end
-
-        it "should return a RackFile adapter as body" do
-          expect(@response).to receive(:body=).with(be_a(Puppet::Network::HTTP::RackREST::RackFile))
-
-          @handler.set_response(@response, @file, 200)
-        end
-      end
-
-      it "should ensure the body has been read on success" do
-        req = mk_req('/production/report/foo', :method => 'PUT')
-        expect(req.body).to receive(:read).at_least(:once)
-
-        allow(Puppet::Transaction::Report).to receive(:save)
-
-        @handler.process(req, @response)
-      end
-
-      it "should ensure the body has been partially read on failure" do
-        req = mk_req('/production/report/foo')
-        expect(req.body).to receive(:read).with(1)
-
-        allow(@handler).to receive(:headers).and_raise(StandardError)
-
-        @handler.process(req, @response)
-      end
-    end
-
-    describe "and determining the request parameters" do
-      it "should include the HTTP request parameters, with the keys as symbols" do
-        req = mk_req('/?foo=baz&bar=xyzzy')
-        result = @handler.params(req)
-        expect(result[:foo]).to eq("baz")
-        expect(result[:bar]).to eq("xyzzy")
-      end
-
-      it "should return multi-values params as an array of the values" do
-        req = mk_req('/?foo=baz&foo=xyzzy')
-        result = @handler.params(req)
-        expect(result[:foo]).to eq(["baz", "xyzzy"])
-      end
-
-      it "should return parameters from the POST body" do
-        req = mk_req("/", :method => 'POST', :input => 'foo=baz&bar=xyzzy')
-        result = @handler.params(req)
-        expect(result[:foo]).to eq("baz")
-        expect(result[:bar]).to eq("xyzzy")
-      end
-
-      it "should not return multi-valued params in a POST body as an array of values" do
-        req = mk_req("/", :method => 'POST', :input => 'foo=baz&foo=xyzzy')
-        result = @handler.params(req)
-        expect(result[:foo]).to be_one_of("baz", "xyzzy")
-      end
-
-      it "should CGI-decode the HTTP parameters" do
-        encoding = Puppet::Util.uri_query_encode("foo bar")
-        req = mk_req("/?foo=#{encoding}")
-        result = @handler.params(req)
-        expect(result[:foo]).to eq("foo bar")
-      end
-
-      it "should convert the string 'true' to the boolean" do
-        req = mk_req("/?foo=true")
-        result = @handler.params(req)
-        expect(result[:foo]).to be_truthy
-      end
-
-      it "should convert the string 'false' to the boolean" do
-        req = mk_req("/?foo=false")
-        result = @handler.params(req)
-        expect(result[:foo]).to be_falsey
-      end
-
-      it "should convert integer arguments to Integers" do
-        req = mk_req("/?foo=15")
-        result = @handler.params(req)
-        expect(result[:foo]).to eq(15)
-      end
-
-      it "should convert floating point arguments to Floats" do
-        req = mk_req("/?foo=1.5")
-        result = @handler.params(req)
-        expect(result[:foo]).to eq(1.5)
-      end
-
-      it "should treat YAML encoded parameters like it was any string" do
-        escaping = Puppet::Util.uri_query_encode(YAML.dump(%w{one two}))
-        req = mk_req("/?foo=#{escaping}")
-        expect(@handler.params(req)[:foo]).to eq("---\n- one\n- two\n")
-      end
-
-      it "should not allow the client to set the node via the query string" do
-        req = mk_req("/?node=foo")
-        expect(@handler.params(req)[:node]).to be_nil
-      end
-
-      it "should not allow the client to set the IP address via the query string" do
-        req = mk_req("/?ip=foo")
-        expect(@handler.params(req)[:ip]).to be_nil
-      end
-
-      it "should pass the client's ip address to model find" do
-        req = mk_req("/", 'REMOTE_ADDR' => 'ipaddress')
-        expect(@handler.params(req)[:ip]).to eq("ipaddress")
-      end
-
-      it "should set 'authenticated' to false if no certificate is present" do
-        req = mk_req('/')
-        expect(@handler.params(req)[:authenticated]).to be_falsey
-      end
-    end
-
-    describe "with pre-validated certificates" do
-      it "should retrieve the hostname by finding the CN given in :ssl_client_header, in the format returned by Apache (RFC2253)" do
-        Puppet[:ssl_client_header] = "myheader"
-        req = mk_req('/', "myheader" => "O=Foo\\, Inc,CN=host.domain.com")
-        expect(@handler.params(req)[:node]).to eq("host.domain.com")
-      end
-
-      it "should retrieve the hostname by finding the CN given in :ssl_client_header, in the format returned by nginx" do
-        Puppet[:ssl_client_header] = "myheader"
-        req = mk_req('/', "myheader" => "/CN=host.domain.com")
-        expect(@handler.params(req)[:node]).to eq("host.domain.com")
-      end
-
-      it "should retrieve the hostname by finding the CN given in :ssl_client_header, ignoring other fields" do
-        Puppet[:ssl_client_header] = "myheader"
-        req = mk_req('/', "myheader" => 'ST=Denial,CN=host.domain.com,O=Domain\\, Inc.')
-        expect(@handler.params(req)[:node]).to eq("host.domain.com")
-      end
-
-      it "should use the :ssl_client_header to determine the parameter for checking whether the host certificate is valid" do
-        Puppet[:ssl_client_header] = "certheader"
-        Puppet[:ssl_client_verify_header] = "myheader"
-        req = mk_req('/', "myheader" => "SUCCESS", "certheader" => "CN=host.domain.com")
-        expect(@handler.params(req)[:authenticated]).to be_truthy
-      end
-
-      it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
-        Puppet[:ssl_client_header] = "certheader"
-        Puppet[:ssl_client_verify_header] = "myheader"
-        req = mk_req('/', "myheader" => "whatever", "certheader" => "CN=host.domain.com")
-        expect(@handler.params(req)[:authenticated]).to be_falsey
-      end
-
-      it "should consider the host unauthenticated if no certificate information is present" do
-        Puppet[:ssl_client_header] = "certheader"
-        Puppet[:ssl_client_verify_header] = "myheader"
-        req = mk_req('/', "myheader" => nil, "certheader" => "CN=host.domain.com")
-        expect(@handler.params(req)[:authenticated]).to be_falsey
-      end
-
-      it "should resolve the node name with an ip address look-up if no certificate is present" do
-        Puppet[:ssl_client_header] = "myheader"
-        req = mk_req('/', "myheader" => nil)
-        expect(@handler).to receive(:resolve_node).and_return("host.domain.com")
-        expect(@handler.params(req)[:node]).to eq("host.domain.com")
-      end
-
-      it "should resolve the node name with an ip address look-up if a certificate without a CN is present" do
-        Puppet[:ssl_client_header] = "myheader"
-        req = mk_req('/', "myheader" => "O=no CN")
-        expect(@handler).to receive(:resolve_node).and_return("host.domain.com")
-        expect(@handler.params(req)[:node]).to eq("host.domain.com")
-      end
-
-      it "should not allow authentication via the verify header if there is no CN available" do
-        Puppet[:ssl_client_header] = "dn_header"
-        Puppet[:ssl_client_verify_header] = "verify_header"
-        req = mk_req('/', "dn_header" => "O=no CN", "verify_header" => 'SUCCESS')
-
-        expect(@handler).to receive(:resolve_node).and_return("host.domain.com")
-
-        expect(@handler.params(req)[:authenticated]).to be_falsey
-      end
-    end
-  end
-end
-
-describe Puppet::Network::HTTP::RackREST::RackFile do
-  before(:each) do
-    stat = double('stat', :size => 100)
-    @file = double('file', :stat => stat, :path => "/tmp/path")
-    @rackfile = Puppet::Network::HTTP::RackREST::RackFile.new(@file)
-  end
-
-  it "should have an each method" do
-    expect(@rackfile).to be_respond_to(:each)
-  end
-
-  it "should yield file chunks by chunks" do
-    expect(@file).to receive(:read).exactly(3).times.with(8192).and_return("1", "2", nil)
-    i = 1
-    @rackfile.each do |chunk|
-      expect(chunk.to_i).to eq(i)
-      i += 1
-    end
-  end
-
-  it "should have a close method" do
-    expect(@rackfile).to be_respond_to(:close)
-  end
-
-  it "should delegate close to File close" do
-    expect(@file).to receive(:close)
-    @rackfile.close
-  end
-end

data/spec/unit/network/http/rack_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-require 'puppet/network/http/rack' if Puppet.features.rack?
-
-describe "Puppet::Network::HTTP::Rack", :if => Puppet.features.rack? do
-  describe "when called" do
-    before :all do
-      @app = Puppet::Network::HTTP::Rack.new()
-      # let's use Rack::Lint to verify that we're OK with the rack specification
-      @linted = Rack::Lint.new(@app)
-    end
-
-    before :each do
-      @env = Rack::MockRequest.env_for('/')
-    end
-
-    it "should create a Request object" do
-      request = Rack::Request.new(@env)
-      expect(Rack::Request).to receive(:new).and_return(request)
-      @linted.call(@env)
-    end
-
-    it "should create a Response object" do
-      expect(Rack::Response).to receive(:new).and_return(double('rack response', :[]= => nil, :status= => nil, :write => nil, :finish => nil))
-      @app.call(@env) # can't lint when Rack::Response is a stub
-    end
-
-    it "should let RackREST process the request" do
-      expect_any_instance_of(Puppet::Network::HTTP::RackREST).to receive(:process).once
-      @linted.call(@env)
-    end
-
-    it "should catch unhandled exceptions from RackREST" do
-      expect_any_instance_of(Puppet::Network::HTTP::RackREST).to receive(:process).and_raise(ArgumentError, 'test error')
-      expect { @linted.call(@env) }.not_to raise_error
-    end
-
-    it "should finish() the Response" do
-      expect_any_instance_of(Rack::Response).to receive(:finish).once
-      @app.call(@env) # can't lint when finish is a stub
-    end
-  end
-end

data/spec/unit/network/http/webrick/rest_spec.rb

@@ -1,230 +0,0 @@
-require 'spec_helper'
-require 'puppet/network/http'
-require 'webrick'
-require 'puppet/network/http/webrick/rest'
-
-describe Puppet::Network::HTTP::WEBrickREST do
-  it "should include the Puppet::Network::HTTP::Handler module" do
-    expect(Puppet::Network::HTTP::WEBrickREST.ancestors).to be_include(Puppet::Network::HTTP::Handler)
-  end
-
-  describe "when receiving a request" do
-    before do
-      @request     = double('webrick http request', :query => {},
-                            :query_string => 'environment=production',
-                            :peeraddr => %w{eh boo host ip},
-                            :request_method => 'GET',
-                            :client_cert => nil)
-      @response    = double('webrick http response')
-      @model_class = double('indirected model class')
-      @webrick     = double('webrick http server', :mount => true, :[] => {})
-      allow(Puppet::Indirector::Indirection).to receive(:model).with(:foo).and_return(@model_class)
-      @handler = Puppet::Network::HTTP::WEBrickREST.new(@webrick)
-    end
-
-    it "should delegate its :service method to its :process method" do
-      expect(@handler).to receive(:process).with(@request, @response).and_return("stuff")
-      expect(@handler.service(@request, @response)).to eq("stuff")
-    end
-
-    describe "#headers" do
-      let(:fake_request) { {"Foo" => "bar", "BAZ" => "bam" } }
-
-      it "should iterate over the request object using #each" do
-        expect(fake_request).to receive(:each)
-        @handler.headers(fake_request)
-      end
-
-      it "should return a hash with downcased header names" do
-        result = @handler.headers(fake_request)
-        expect(result).to eq(fake_request.inject({}) { |m,(k,v)| m[k.downcase] = v; m })
-      end
-    end
-
-    describe "when using the Handler interface" do
-      it "should use the request method as the http method" do
-        expect(@request).to receive(:request_method).and_return("FOO")
-        expect(@handler.http_method(@request)).to eq("FOO")
-      end
-
-      it "should return the request path as the path" do
-        expect(@request).to receive(:path).and_return("/foo/bar")
-        expect(@handler.path(@request)).to eq("/foo/bar")
-      end
-
-      it "should return the request body as the body" do
-        allow(@request).to receive(:request_method).and_return("POST")
-        expect(@request).to receive(:body).and_return("my body")
-        expect(@handler.body(@request)).to eq("my body")
-      end
-
-      it "should set the response's 'content-type' header when setting the content type" do
-        expect(@response).to receive(:[]=).with("content-type", "text/html")
-        @handler.set_content_type(@response, "text/html")
-      end
-
-      it "should set the status and body on the response when setting the response for a successful query" do
-        expect(@response).to receive(:status=).with(200)
-        expect(@response).to receive(:body=).with("mybody")
-
-        @handler.set_response(@response, "mybody", 200)
-      end
-
-      it "serves a file" do
-        stat = double('stat', :size => 100)
-        @file = double('file', :stat => stat, :path => "/tmp/path")
-        allow(@file).to receive(:is_a?).with(File).and_return(true)
-
-        expect(@response).to receive(:[]=).with('content-length', 100)
-        expect(@response).to receive(:status=).with(200)
-        expect(@response).to receive(:body=).with(@file)
-
-        @handler.set_response(@response, @file, 200)
-      end
-
-      it "should set the status and message on the response when setting the response for a failed query" do
-        expect(@response).to receive(:status=).with(400)
-        expect(@response).to receive(:body=).with("mybody")
-
-        @handler.set_response(@response, "mybody", 400)
-      end
-    end
-
-    describe "and determining the request parameters" do
-      def query_of(options)
-        request = Puppet::Indirector::Request.new(:myind, :find, "my key", nil, options)
-        WEBrick::HTTPUtils.parse_query(request.query_string.sub(/^\?/, ''))
-      end
-
-      def a_request_querying(query_data)
-        expect(@request).to receive(:query).and_return(query_of(query_data))
-        @request
-      end
-
-      def certificate_with_subject(subj)
-        cert = OpenSSL::X509::Certificate.new
-        cert.subject = OpenSSL::X509::Name.parse(subj)
-        cert
-      end
-
-      it "has no parameters when there is no query string" do
-        only_server_side_information = [:authenticated, :ip, :node]
-        allow(@request).to receive(:query).and_return(nil)
-
-        result = @handler.params(@request)
-
-        expect(result.keys.sort).to eq(only_server_side_information)
-      end
-
-      it "should prefer duplicate params from the body over the query string" do
-        allow(@request).to receive(:request_method).and_return("PUT")
-        allow(@request).to receive(:query).and_return(WEBrick::HTTPUtils.parse_query("foo=bar&environment=posted_env"))
-        expect(@handler.params(@request)[:environment]).to eq("posted_env")
-      end
-
-      it "should include the HTTP request parameters, with the keys as symbols" do
-        request = a_request_querying("foo" => "baz", "bar" => "xyzzy")
-        result = @handler.params(request)
-
-        expect(result[:foo]).to eq("baz")
-        expect(result[:bar]).to eq("xyzzy")
-      end
-
-      it "should handle parameters with no value" do
-        request = a_request_querying('foo' => "")
-
-        result = @handler.params(request)
-
-        expect(result[:foo]).to eq("")
-      end
-
-      it "should convert the string 'true' to the boolean" do
-        request = a_request_querying('foo' => "true")
-
-        result = @handler.params(request)
-
-        expect(result[:foo]).to eq(true)
-      end
-
-      it "should convert the string 'false' to the boolean" do
-        request = a_request_querying('foo' => "false")
-
-        result = @handler.params(request)
-
-        expect(result[:foo]).to eq(false)
-      end
-
-      it "should reconstruct arrays" do
-        request = a_request_querying('foo' => ["a", "b", "c"])
-
-        result = @handler.params(request)
-
-        expect(result[:foo]).to eq(["a", "b", "c"])
-      end
-
-      it "should convert values inside arrays into primitive types" do
-        request = a_request_querying('foo' => ["true", "false", "1", "1.2"])
-
-        result = @handler.params(request)
-
-        expect(result[:foo]).to eq([true, false, 1, 1.2])
-      end
-
-      it "should treat YAML-load values that are YAML-encoded as any other String" do
-        request = a_request_querying('foo' => YAML.dump(%w{one two}))
-        expect(@handler.params(request)[:foo]).to eq("---\n- one\n- two\n")
-      end
-
-      it "should not allow clients to set the node via the request parameters" do
-        request = a_request_querying("node" => "foo")
-        allow(@handler).to receive(:resolve_node)
-
-        expect(@handler.params(request)[:node]).to be_nil
-      end
-
-      it "should not allow clients to set the IP via the request parameters" do
-        request = a_request_querying("ip" => "foo")
-
-        expect(@handler.params(request)[:ip]).not_to eq("foo")
-      end
-
-      it "should pass the client's ip address to model find" do
-        allow(@request).to receive(:peeraddr).and_return(%w{noidea dunno hostname ipaddress})
-        expect(@handler.params(@request)[:ip]).to eq("ipaddress")
-      end
-
-      it "should set 'authenticated' to true if a certificate is present" do
-        cert = double('cert', :subject => [%w{CN host.domain.com}])
-        allow(@request).to receive(:client_cert).and_return(cert)
-        expect(@handler.params(@request)[:authenticated]).to be_truthy
-      end
-
-      it "should set 'authenticated' to false if no certificate is present" do
-        allow(@request).to receive(:client_cert).and_return(nil)
-        expect(@handler.params(@request)[:authenticated]).to be_falsey
-      end
-
-      it "should pass the client's certificate name to model method if a certificate is present" do
-        allow(@request).to receive(:client_cert).and_return(certificate_with_subject("/CN=host.domain.com"))
-
-        expect(@handler.params(@request)[:node]).to eq("host.domain.com")
-      end
-
-      it "should resolve the node name with an ip address look-up if no certificate is present" do
-        allow(@request).to receive(:client_cert).and_return(nil)
-
-        expect(@handler).to receive(:resolve_node).and_return(:resolved_node)
-
-        expect(@handler.params(@request)[:node]).to eq(:resolved_node)
-      end
-
-      it "should resolve the node name with an ip address look-up if CN parsing fails" do
-        allow(@request).to receive(:client_cert).and_return(certificate_with_subject("/C=company"))
-
-        expect(@handler).to receive(:resolve_node).and_return(:resolved_node)
-
-        expect(@handler.params(@request)[:node]).to eq(:resolved_node)
-      end
-    end
-  end
-end