puppet 3.2.4 → 3.3.0.rc2

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

@@ -34,7 +34,7 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
     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',
+                           'HTTP_X_Custom_Header' => 'mycustom',
                            'NOT_HTTP_foo' => 'not an http header'})
         @handler.headers(req).should == {"accept" => 'myaccept',
                                          "x-custom-header" => 'mycustom'}

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

@@ -125,49 +125,100 @@ describe Puppet::Network::HTTP::WEBrickREST do
     end
 
     describe "and determining the request parameters" do
-      it "should include the HTTP request parameters, with the keys as symbols" do
-        @request.stubs(:query).returns("foo" => "baz", "bar" => "xyzzy")
+      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)
+        @request.expects(:query).returns(query_of(query_data))
+        @request
+      end
+
+      it "has no parameters when there is no query string" do
+        only_server_side_information = [:authenticated, :ip, :node]
+        @request.stubs(:query).returns(nil)
+
         result = @handler.params(@request)
+
+        result.keys.sort.should == only_server_side_information
+      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)
+
         result[:foo].should == "baz"
         result[:bar].should == "xyzzy"
       end
 
-      it "should CGI-decode the HTTP parameters" do
-        encoding = CGI.escape("foo bar")
-        @request.expects(:query).returns('foo' => encoding)
-        result = @handler.params(@request)
-        result[:foo].should == "foo bar"
+      it "should handle parameters with no value" do
+        request = a_request_querying('foo' => "")
+
+        result = @handler.params(request)
+
+        result[:foo].should == ""
       end
 
       it "should convert the string 'true' to the boolean" do
-        @request.expects(:query).returns('foo' => "true")
-        result = @handler.params(@request)
-        result[:foo].should be_true
+        request = a_request_querying('foo' => "true")
+
+        result = @handler.params(request)
+
+        result[:foo].should == true
       end
 
       it "should convert the string 'false' to the boolean" do
-        @request.expects(:query).returns('foo' => "false")
-        result = @handler.params(@request)
-        result[:foo].should be_false
+        request = a_request_querying('foo' => "false")
+
+        result = @handler.params(request)
+
+        result[:foo].should == false
       end
 
-      it "should YAML-load and CGI-decode values that are YAML-encoded" do
-        escaping = CGI.escape(YAML.dump(%w{one two}))
-        @request.expects(:query).returns('foo' => escaping)
-        result = @handler.params(@request)
+      it "should reconstruct arrays" do
+        request = a_request_querying('foo' => ["a", "b", "c"])
+
+        result = @handler.params(request)
+
+        result[:foo].should == ["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)
+
+        result[:foo].should == [true, false, 1, 1.2]
+      end
+
+      it "should YAML-load values that are YAML-encoded" do
+        request = a_request_querying('foo' => YAML.dump(%w{one two}))
+
+        result = @handler.params(request)
+
+        result[:foo].should == %w{one two}
+      end
+
+      it "should YAML-load that are YAML-encoded" do
+        request = a_request_querying('foo' => YAML.dump(%w{one two}))
+
+        result = @handler.params(request)
+
         result[:foo].should == %w{one two}
       end
 
       it "should not allow clients to set the node via the request parameters" do
-        @request.stubs(:query).returns("node" => "foo")
+        request = a_request_querying("node" => "foo")
         @handler.stubs(:resolve_node)
 
-        @handler.params(@request)[:node].should be_nil
+        @handler.params(request)[:node].should be_nil
       end
 
       it "should not allow clients to set the IP via the request parameters" do
-        @request.stubs(:query).returns("ip" => "foo")
-        @handler.params(@request)[:ip].should_not == "foo"
+        request = a_request_querying("ip" => "foo")
+
+        @handler.params(request)[:ip].should_not == "foo"
       end
 
       it "should pass the client's ip address to model find" do
@@ -212,6 +263,6 @@ describe Puppet::Network::HTTP::WEBrickREST do
 
         @handler.params(@request)[:node].should == :resolved_node
       end
-    end
+   end
   end
 end

data/spec/unit/network/http_pool_spec.rb

@@ -22,6 +22,46 @@ describe Puppet::Network::HttpPool do
       Puppet::Network::HttpPool.http_instance("me", 54321, true).should be_use_ssl
     end
 
+
+    describe 'peer verification' do
+      def setup_standard_ssl_configuration
+        ca_cert_file = File.expand_path('/path/to/ssl/certs/ca_cert.pem')
+        FileTest.stubs(:exist?).with(ca_cert_file).returns(true)
+
+        ssl_configuration = stub('ssl_configuration', :ca_auth_file => ca_cert_file)
+        Puppet::Network::HTTP::Connection.any_instance.stubs(:ssl_configuration).returns(ssl_configuration)
+      end
+
+      def setup_standard_hostcert
+        host_cert_file = File.expand_path('/path/to/ssl/certs/host_cert.pem')
+        FileTest.stubs(:exist?).with(host_cert_file).returns(true)
+
+        Puppet[:hostcert] = host_cert_file
+      end
+
+      def setup_standard_ssl_host
+        cert = stub('cert', :content => 'real_cert')
+        key  = stub('key',  :content => 'real_key')
+        host = stub('host', :certificate => cert, :key => key, :ssl_store => stub('store'))
+
+        Puppet::Network::HTTP::Connection.any_instance.stubs(:ssl_host).returns(host)
+      end
+
+      before do
+        setup_standard_ssl_configuration
+        setup_standard_hostcert
+        setup_standard_ssl_host
+      end
+
+      it 'can enable peer verification' do
+        Puppet::Network::HttpPool.http_instance("me", 54321, true, true).send(:connection).verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+      end
+
+      it 'can disable peer verification' do
+        Puppet::Network::HttpPool.http_instance("me", 54321, true, false).send(:connection).verify_mode.should == OpenSSL::SSL::VERIFY_NONE
+      end
+    end
+
     it "should not cache http instances" do
       Puppet::Network::HttpPool.http_instance("me", 54321).
         should_not equal Puppet::Network::HttpPool.http_instance("me", 54321)

data/spec/unit/network/server_spec.rb

@@ -5,30 +5,19 @@ require 'puppet/network/server'
 describe Puppet::Network::Server do
   let(:port) { 8140 }
   let(:address) { '0.0.0.0' }
-  let(:server) {
-    server = Puppet::Network::Server.new(address, port)
-    server.stubs(:close_streams)
-    server
-  }
+  let(:server) { Puppet::Network::Server.new(address, port) }
 
   before do
     @mock_http_server = mock('http server')
     Puppet.settings.stubs(:use)
-    Puppet.run_mode.stubs(:name).returns :master
     Puppet::Network::HTTP::WEBrick.stubs(:new).returns(@mock_http_server)
   end
 
   describe "when initializing" do
     before do
-      Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
       Puppet[:masterport] = ''
     end
 
-    it "should allow registering REST handlers" do
-      server = Puppet::Network::Server.new(address, port, [:foo, :bar, :baz])
-      expect { server.unregister(:foo, :bar, :baz) }.to_not raise_error
-    end
-
     it "should not be listening after initialization" do
       Puppet::Network::Server.new(address, port).should_not be_listening
     end
@@ -45,173 +34,7 @@ describe Puppet::Network::Server do
     end
   end
 
-  describe "when being started" do
-    before do
-      server.stubs(:listen)
-      server.stubs(:create_pidfile)
-    end
-
-    it "should listen" do
-      server.expects(:listen)
-      server.start
-    end
-
-    it "should create its PID file" do
-      server.expects(:create_pidfile)
-      server.start
-    end
-  end
-
-  describe "when being stopped" do
-    before do
-      server.stubs(:unlisten)
-      server.stubs(:remove_pidfile)
-    end
-
-    it "should unlisten" do
-      server.expects(:unlisten)
-      server.stop
-    end
-
-    it "should remove its PID file" do
-      server.expects(:remove_pidfile)
-      server.stop
-    end
-  end
-
-  describe "when creating its pidfile" do
-    it "should use an exclusive mutex" do
-      Puppet.run_mode.expects(:name).returns "me"
-      Puppet::Util.expects(:synchronize_on).with("me", Sync::EX)
-      server.create_pidfile
-    end
-
-    it "should lock the pidfile using the Pidlock class" do
-      pidfile = mock 'pidfile'
-
-      Puppet.run_mode.expects(:name).returns "eh"
-      Puppet[:pidfile] = File.expand_path("/my/file")
-
-      Puppet::Util::Pidlock.expects(:new).with(Puppet[:pidfile]).returns pidfile
-
-      pidfile.expects(:lock).returns true
-      server.create_pidfile
-    end
-
-    it "should fail if it cannot lock" do
-      pidfile = mock 'pidfile'
-
-      Puppet[:pidfile] = File.expand_path("/my/file")
-
-      Puppet::Util::Pidlock.expects(:new).with(Puppet[:pidfile]).returns pidfile
-
-      pidfile.expects(:lock).returns false
-
-      expect { server.create_pidfile }.to raise_error /Could not create PID/
-    end
-  end
-
-  describe "when removing its pidfile" do
-    it "should use an exclusive mutex" do
-      Puppet.run_mode.expects(:name).returns "me"
-      Puppet::Util.expects(:synchronize_on).with("me",Sync::EX)
-      server.remove_pidfile
-    end
-
-    it "should do nothing if the pidfile is not present" do
-      pidfile = mock 'pidfile', :unlock => false
-      Puppet[:pidfile] = "/my/file"
-      Puppet::Util::Pidlock.expects(:new).with(Puppet[:pidfile]).returns pidfile
-
-      server.remove_pidfile
-    end
-
-    it "should unlock the pidfile using the Pidlock class" do
-      pidfile = mock 'pidfile', :unlock => true
-      Puppet[:pidfile] = "/my/file"
-      Puppet::Util::Pidlock.expects(:new).with(Puppet[:pidfile]).returns pidfile
-
-      server.remove_pidfile
-    end
-  end
-
-  describe "when managing indirection registrations" do
-    before do
-      Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
-    end
-
-    it "should allow registering an indirection for client access by specifying its indirection name" do
-      expect { server.register(:foo) }.to_not raise_error
-    end
-
-    it "should require that the indirection be valid" do
-      Puppet::Indirector::Indirection.expects(:model).with(:foo).returns nil
-      expect { server.register(:foo) }.to raise_error(ArgumentError)
-    end
-
-    it "should require at least one indirection name when registering indirections for client access" do
-      expect { server.register }.to raise_error(ArgumentError)
-    end
-
-    it "should allow for numerous indirections to be registered at once for client access" do
-      expect { server.register(:foo, :bar, :baz) }.to_not raise_error
-    end
-
-    it "should allow the use of indirection names to specify which indirections are to be no longer accessible to clients" do
-      server.register(:foo)
-      expect { server.unregister(:foo) }.to_not raise_error
-    end
-
-    it "should leave other indirections accessible to clients when turning off indirections" do
-      server.register(:foo, :bar)
-      server.unregister(:foo)
-      expect { server.unregister(:bar)}.to_not raise_error
-    end
-
-    it "should allow specifying numerous indirections which are to be no longer accessible to clients" do
-      server.register(:foo, :bar)
-      expect { server.unregister(:foo, :bar) }.to_not raise_error
-    end
-
-    it "should not turn off any indirections if given unknown indirection names to turn off" do
-      server.register(:foo, :bar)
-      expect { server.unregister(:foo, :bar, :baz) }.to raise_error(ArgumentError)
-      expect { server.unregister(:foo, :bar) }.to_not raise_error
-    end
-
-    it "should not allow turning off unknown indirection names" do
-      server.register(:foo, :bar)
-      expect { server.unregister(:baz) }.to raise_error(ArgumentError)
-    end
-
-    it "should disable client access immediately when turning off indirections" do
-      server.register(:foo, :bar)
-      server.unregister(:foo)
-      expect { server.unregister(:foo) }.to raise_error(ArgumentError)
-    end
-
-    it "should allow turning off all indirections at once" do
-      server.register(:foo, :bar)
-      server.unregister
-      [:foo, :bar, :baz].each do |indirection|
-        expect { server.unregister(indirection) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  it "should allow for multiple configurations, each handling different indirections" do
-    Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
-
-    server2 = Puppet::Network::Server.new(address, port)
-    server.register(:foo, :bar)
-    server2.register(:foo, :xyzzy)
-    server.unregister(:foo, :bar)
-    server2.unregister(:foo, :xyzzy)
-    expect { server.unregister(:xyzzy) }.to raise_error(ArgumentError)
-    expect { server2.unregister(:bar) }.to raise_error(ArgumentError)
-  end
-
-  describe "when listening is off" do
+  describe "when not yet started" do
     before do
       @mock_http_server.stubs(:listen)
     end
@@ -220,65 +43,53 @@ describe Puppet::Network::Server do
       server.should_not be_listening
     end
 
-    it "should not allow listening to be turned off" do
-      expect { server.unlisten }.to raise_error(RuntimeError)
+    it "should not allow server to be stopped" do
+      expect { server.stop }.to raise_error(RuntimeError)
     end
 
-    it "should allow listening to be turned on" do
-      expect { server.listen }.to_not raise_error
+    it "should allow server to be started" do
+      expect { server.start }.to_not raise_error
     end
-
   end
 
-  describe "when listening is on" do
+  describe "when server is on" do
     before do
       @mock_http_server.stubs(:listen)
       @mock_http_server.stubs(:unlisten)
-      server.listen
+      server.start
     end
 
     it "should indicate that it is listening" do
       server.should be_listening
     end
 
-    it "should not allow listening to be turned on" do
-      expect { server.listen }.to raise_error(RuntimeError)
+    it "should not allow server to be started again" do
+      expect { server.start }.to raise_error(RuntimeError)
     end
 
-    it "should allow listening to be turned off" do
-      expect { server.unlisten }.to_not raise_error
+    it "should allow server to be stopped" do
+      expect { server.stop }.to_not raise_error
     end
   end
 
-  describe "when listening is being turned on" do
-    before do
-      Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
-    end
-
+  describe "when server is being started" do
     it "should cause the HTTP server to listen" do
-      server = Puppet::Network::Server.new(address, port, [:node])
+      server = Puppet::Network::Server.new(address, port)
       @mock_http_server.expects(:listen).with(address, port)
-      server.listen
+      server.start
     end
   end
 
-  describe "when listening is being turned off" do
+  describe "when server is being stopped" do
     before do
       @mock_http_server.stubs(:listen)
       server.stubs(:http_server).returns(@mock_http_server)
-      server.listen
+      server.start
     end
 
     it "should cause the HTTP server to stop listening" do
       @mock_http_server.expects(:unlisten)
-      server.unlisten
-    end
-
-    it "should not allow for indirections to be turned off" do
-      Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
-
-      server.register(:foo)
-      expect { server.unregister(:foo) }.to raise_error(RuntimeError)
+      server.stop
     end
   end
 end