puppet 0.25.5 → 2.6.0

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

@@ -0,0 +1,249 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+
+require 'puppet/network/http'
+
+describe "Puppet::Network::HTTP::MongrelREST" do
+  confine "Mongrel is not available" => Puppet.features.mongrel?
+  before do
+    require 'puppet/network/http/mongrel/rest'
+  end
+
+
+  it "should include the Puppet::Network::HTTP::Handler module" do
+    Puppet::Network::HTTP::MongrelREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
+  end
+
+  describe "when initializing" do
+    it "should call the Handler's initialization hook with its provided arguments as the server and handler" do
+      Puppet::Network::HTTP::MongrelREST.any_instance.expects(:initialize_for_puppet).with(:server => "my", :handler => "arguments")
+      Puppet::Network::HTTP::MongrelREST.new(:server => "my", :handler => "arguments")
+    end
+  end
+
+  describe "when receiving a request" do
+    before do
+      @params = {}
+      @request = stub('mongrel http request', :params => @params)
+
+      @head = stub('response head')
+      @body = stub('response body', :write => true)
+      @response = stub('mongrel http response')
+      @response.stubs(:start).yields(@head, @body)
+      @model_class = stub('indirected model class')
+      @mongrel = stub('mongrel http server', :register => true)
+      Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
+      @handler = Puppet::Network::HTTP::MongrelREST.new(:server => @mongrel, :handler => :foo)
+    end
+
+    describe "and using the HTTP Handler interface" do
+      it "should return the HTTP_ACCEPT parameter as the accept header" do
+        @params.expects(:[]).with("HTTP_ACCEPT").returns "myaccept"
+        @handler.accept_header(@request).should == "myaccept"
+      end
+
+      it "should return the Content-Type parameter as the Content-Type header" do
+        @params.expects(:[]).with("HTTP_CONTENT_TYPE").returns "mycontent"
+        @handler.content_type_header(@request).should == "mycontent"
+      end
+
+      it "should use the REQUEST_METHOD as the http method" do
+        @params.expects(:[]).with(Mongrel::Const::REQUEST_METHOD).returns "mymethod"
+        @handler.http_method(@request).should == "mymethod"
+      end
+
+      it "should return the request path as the path" do
+        @params.expects(:[]).with(Mongrel::Const::REQUEST_PATH).returns "/foo/bar"
+        @handler.path(@request).should == "/foo/bar"
+      end
+
+      it "should return the request body as the body" do
+        @request.expects(:body).returns StringIO.new("mybody")
+        @handler.body(@request).should == "mybody"
+      end
+
+      it "should set the response's content-type header when setting the content type" do
+        @header = mock 'header'
+        @response.expects(:header).returns @header
+        @header.expects(:[]=).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 successful request" do
+        head = mock 'head'
+        body = mock 'body'
+        @response.expects(:start).with(200).yields(head, body)
+
+        body.expects(:write).with("mybody")
+
+        @handler.set_response(@response, "mybody", 200)
+      end
+
+      describe "when the result is a File" do
+        it "should use response send_file" do
+          head = mock 'head'
+          body = mock 'body'
+          stat = stub 'stat', :size => 100
+          file = stub 'file', :stat => stat, :path => "/tmp/path"
+          file.stubs(:is_a?).with(File).returns(true)
+
+          @response.expects(:start).with(200).yields(head, body)
+          @response.expects(:send_status).with(100)
+          @response.expects(:send_header)
+          @response.expects(:send_file).with("/tmp/path")
+
+          @handler.set_response(@response, file, 200)
+        end
+      end
+
+      it "should set the status and reason and write the body when setting the response for a successful request" do
+        head = mock 'head'
+        body = mock 'body'
+        @response.expects(:start).with(400, false, "mybody").yields(head, body)
+
+        body.expects(:write).with("mybody")
+
+        @handler.set_response(@response, "mybody", 400)
+      end
+    end
+
+    describe "and determining the request parameters" do
+      before do
+        @request.stubs(:params).returns({})
+      end
+
+      it "should skip empty parameter values" do
+        @request.expects(:params).returns('QUERY_STRING' => "&=")
+        lambda { @handler.params(@request) }.should_not raise_error
+      end
+
+      it "should include the HTTP request parameters, with the keys as symbols" do
+        @request.expects(:params).returns('QUERY_STRING' => '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(:params).returns('QUERY_STRING' => "foo=#{encoding}")
+        result = @handler.params(@request)
+        result[:foo].should == "foo bar"
+      end
+
+      it "should convert the string 'true' to the boolean" do
+        @request.expects(:params).returns('QUERY_STRING' => 'foo=true')
+        result = @handler.params(@request)
+        result[:foo].should be_true
+      end
+
+      it "should convert the string 'false' to the boolean" do
+        @request.expects(:params).returns('QUERY_STRING' => 'foo=false')
+        result = @handler.params(@request)
+        result[:foo].should be_false
+      end
+
+      it "should convert integer arguments to Integers" do
+        @request.expects(:params).returns('QUERY_STRING' => 'foo=15')
+        result = @handler.params(@request)
+        result[:foo].should == 15
+      end
+
+      it "should convert floating point arguments to Floats" do
+        @request.expects(:params).returns('QUERY_STRING' => 'foo=1.5')
+        result = @handler.params(@request)
+        result[:foo].should == 1.5
+      end
+
+      it "should YAML-load and URI-decode values that are YAML-encoded" do
+        escaping = CGI.escape(YAML.dump(%w{one two}))
+        @request.expects(:params).returns('QUERY_STRING' => "foo=#{escaping}")
+        result = @handler.params(@request)
+        result[:foo].should == %w{one two}
+      end
+
+      it "should not allow the client to set the node via the query string" do
+        @request.stubs(:params).returns('QUERY_STRING' => "node=foo")
+        @handler.params(@request)[:node].should be_nil
+      end
+
+      it "should not allow the client to set the IP address via the query string" do
+        @request.stubs(:params).returns('QUERY_STRING' => "ip=foo")
+        @handler.params(@request)[:ip].should be_nil
+      end
+
+      it "should pass the client's ip address to model find" do
+        @request.stubs(:params).returns("REMOTE_ADDR" => "ipaddress")
+        @handler.params(@request)[:ip].should == "ipaddress"
+      end
+
+      it "should pass the client's provided X-Forwared-For value as the ip" do
+        @request.stubs(:params).returns("HTTP_X_FORWARDED_FOR" => "ipaddress")
+        @handler.params(@request)[:ip].should == "ipaddress"
+      end
+
+      it "should pass the client's provided X-Forwared-For first value as the ip" do
+        @request.stubs(:params).returns("HTTP_X_FORWARDED_FOR" => "ipproxy1,ipproxy2,ipaddress")
+        @handler.params(@request)[:ip].should == "ipaddress"
+      end
+
+      it "should pass the client's provided X-Forwared-For value as the ip instead of the REMOTE_ADDR" do
+        @request.stubs(:params).returns("REMOTE_ADDR" => "remote_addr")
+        @request.stubs(:params).returns("HTTP_X_FORWARDED_FOR" => "ipaddress")
+        @handler.params(@request)[:ip].should == "ipaddress"
+      end
+
+      it "should use the :ssl_client_header to determine the parameter when looking for the certificate" do
+        Puppet.settings.stubs(:value).returns "eh"
+        Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
+        @request.stubs(:params).returns("myheader" => "/CN=host.domain.com")
+        @handler.params(@request)
+      end
+
+      it "should retrieve the hostname by matching the certificate parameter" do
+        Puppet.settings.stubs(:value).returns "eh"
+        Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
+        @request.stubs(:params).returns("myheader" => "/CN=host.domain.com")
+        @handler.params(@request)[:node].should == "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.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
+        Puppet.settings.expects(:value).with(:ssl_client_verify_header).returns "myheader"
+        @request.stubs(:params).returns("myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
+        @handler.params(@request)
+      end
+
+      it "should consider the host authenticated if the validity parameter contains 'SUCCESS'" do
+        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
+        Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
+        @request.stubs(:params).returns("myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
+        @handler.params(@request)[:authenticated].should be_true
+      end
+
+      it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
+        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
+        Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
+        @request.stubs(:params).returns("myheader" => "whatever", "certheader" => "/CN=host.domain.com")
+        @handler.params(@request)[:authenticated].should be_false
+      end
+
+      it "should consider the host unauthenticated if no certificate information is present" do
+        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
+        Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
+        @request.stubs(:params).returns("myheader" => nil, "certheader" => "SUCCESS")
+        @handler.params(@request)[:authenticated].should be_false
+      end
+
+      it "should resolve the node name with an ip address look-up if no certificate is present" do
+        Puppet.settings.stubs(:value).returns "eh"
+        Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
+        @request.stubs(:params).returns("myheader" => nil)
+        @handler.expects(:resolve_node).returns("host.domain.com")
+        @handler.params(@request)[:node].should == "host.domain.com"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+#
+#  Created by Rick Bradley on 2007-10-15.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'puppet/network/http'
+
+describe "Puppet::Network::HTTP::Mongrel", "after initializing" do
+  confine "Mongrel is not available" => Puppet.features.mongrel?
+
+  it "should not be listening" do
+    require 'puppet/network/http/mongrel'
+
+    Puppet::Network::HTTP::Mongrel.new.should_not be_listening
+  end
+end
+
+describe "Puppet::Network::HTTP::Mongrel", "when turning on listening" do
+  confine "Mongrel is not available" => Puppet.features.mongrel?
+
+  before do
+    require 'puppet/network/http/mongrel'
+
+    @server = Puppet::Network::HTTP::Mongrel.new
+    @mock_mongrel = mock('mongrel')
+    @mock_mongrel.stubs(:run)
+    @mock_mongrel.stubs(:register)
+    Mongrel::HttpServer.stubs(:new).returns(@mock_mongrel)
+
+    @mock_puppet_mongrel = mock('puppet_mongrel')
+    Puppet::Network::HTTPServer::Mongrel.stubs(:new).returns(@mock_puppet_mongrel)
+
+    @listen_params = { :address => "127.0.0.1", :port => 31337, :protocols => [ :rest, :xmlrpc ], :xmlrpc_handlers => [ :status, :fileserver ] }
+  end
+
+  it "should fail if already listening" do
+    @server.listen(@listen_params)
+    Proc.new { @server.listen(@listen_params) }.should raise_error(RuntimeError)
+  end
+
+  it "should require at least one protocol" do
+    Proc.new { @server.listen(@listen_params.delete_if {|k,v| :protocols == k}) }.should raise_error(ArgumentError)
+  end
+
+  it "should require a listening address to be specified" do
+    Proc.new { @server.listen(@listen_params.delete_if {|k,v| :address == k})}.should raise_error(ArgumentError)
+  end
+
+  it "should require a listening port to be specified" do
+    Proc.new { @server.listen(@listen_params.delete_if {|k,v| :port == k})}.should raise_error(ArgumentError)
+  end
+
+  it "should order a mongrel server to start" do
+    @mock_mongrel.expects(:run)
+    @server.listen(@listen_params)
+  end
+
+  it "should tell mongrel to listen on the specified address and port" do
+    Mongrel::HttpServer.expects(:new).with("127.0.0.1", 31337).returns(@mock_mongrel)
+    @server.listen(@listen_params)
+  end
+
+  it "should be listening" do
+    Mongrel::HttpServer.expects(:new).returns(@mock_mongrel)
+    @server.listen(@listen_params)
+    @server.should be_listening
+  end
+
+  describe "when providing REST services" do
+    it "should instantiate a handler at / for handling REST calls" do
+      Puppet::Network::HTTP::MongrelREST.expects(:new).returns "myhandler"
+      @mock_mongrel.expects(:register).with("/", "myhandler")
+
+      @server.listen(@listen_params)
+    end
+
+    it "should use a Mongrel + REST class to configure Mongrel when REST services are requested" do
+      @server.expects(:class_for_protocol).with(:rest).at_least_once.returns(Puppet::Network::HTTP::MongrelREST)
+      @server.listen(@listen_params)
+    end
+  end
+
+  describe "when providing XMLRPC services" do
+    it "should do nothing if no xmlrpc handlers have been provided" do
+      Puppet::Network::HTTPServer::Mongrel.expects(:new).never
+      @server.listen(@listen_params.merge(:xmlrpc_handlers => []))
+    end
+
+    it "should create an instance of the existing Mongrel http server with the right handlers" do
+      Puppet::Network::HTTPServer::Mongrel.expects(:new).with([:status, :master]).returns(@mock_puppet_mongrel)
+      @server.listen(@listen_params.merge(:xmlrpc_handlers => [:status, :master]))
+    end
+
+    it "should register the Mongrel server instance at /RPC2" do
+      @mock_mongrel.expects(:register).with("/RPC2", @mock_puppet_mongrel)
+
+      @server.listen(@listen_params.merge(:xmlrpc_handlers => [:status, :master]))
+    end
+  end
+end
+
+describe "Puppet::Network::HTTP::Mongrel", "when turning off listening" do
+  confine "Mongrel is not available" => Puppet.features.mongrel?
+
+  before do
+    @mock_mongrel = mock('mongrel httpserver')
+    @mock_mongrel.stubs(:run)
+    @mock_mongrel.stubs(:register)
+    Mongrel::HttpServer.stubs(:new).returns(@mock_mongrel)
+    @server = Puppet::Network::HTTP::Mongrel.new
+    @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest ] }
+  end
+
+  it "should fail unless listening" do
+    Proc.new { @server.unlisten }.should raise_error(RuntimeError)
+  end
+
+  it "should order mongrel server to stop" do
+    @server.listen(@listen_params)
+    @mock_mongrel.expects(:stop)
+    @server.unlisten
+  end
+
+  it "should not be listening" do
+    @server.listen(@listen_params)
+    @mock_mongrel.stubs(:stop)
+    @server.unlisten
+    @server.should_not be_listening
+  end
+end

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

@@ -0,0 +1,249 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+require 'puppet/network/http/rack' if Puppet.features.rack?
+require 'puppet/network/http/rack/rest'
+
+describe "Puppet::Network::HTTP::RackREST" do
+  confine "Rack is not available" => Puppet.features.rack?
+
+  it "should include the Puppet::Network::HTTP::Handler module" do
+    Puppet::Network::HTTP::RackREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
+  end
+
+  describe "when initializing" do
+    it "should call the Handler's initialization hook with its provided arguments" do
+      Puppet::Network::HTTP::RackREST.any_instance.expects(:initialize_for_puppet).with(:server => "my", :handler => "arguments")
+      Puppet::Network::HTTP::RackREST.new(:server => "my", :handler => "arguments")
+    end
+  end
+
+  describe "when serving a request" do
+    before :all do
+      @model_class = stub('indirected model class')
+      Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
+      @handler = Puppet::Network::HTTP::RackREST.new(:handler => :foo)
+    end
+
+    before :each do
+      @response = Rack::Response.new
+    end
+
+    def mk_req(uri, opts = {})
+      env = Rack::MockRequest.env_for(uri, opts)
+      Rack::Request.new(env)
+    end
+
+    describe "and using the HTTP Handler interface" do
+      it "should return the HTTP_ACCEPT parameter as the accept header" do
+        req = mk_req('/', 'HTTP_ACCEPT' => 'myaccept')
+        @handler.accept_header(req).should == "myaccept"
+      end
+
+      it "should return the CONTENT_TYPE parameter as the content type header" do
+        req = mk_req('/', 'CONTENT_TYPE' => 'mycontent')
+        @handler.content_type_header(req).should == "mycontent"
+      end
+
+      it "should use the REQUEST_METHOD as the http method" do
+        req = mk_req('/', :method => 'MYMETHOD')
+        @handler.http_method(req).should == "MYMETHOD"
+      end
+
+      it "should return the request path as the path" do
+        req = mk_req('/foo/bar')
+        @handler.path(req).should == "/foo/bar"
+      end
+
+      it "should return the request body as the body" do
+        req = mk_req('/foo/bar', :input => 'mybody')
+        @handler.body(req).should == "mybody"
+      end
+
+      it "should set the response's content-type header when setting the content type" do
+        @header = mock 'header'
+        @response.expects(:header).returns @header
+        @header.expects(:[]=).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
+        @response.expects(:status=).with(400)
+        @response.expects(:write).with("mybody")
+
+        @handler.set_response(@response, "mybody", 400)
+      end
+
+      describe "when result is a File" do
+        before :each do
+          stat = stub 'stat', :size => 100
+          @file = stub 'file', :stat => stat, :path => "/tmp/path"
+          @file.stubs(:is_a?).with(File).returns(true)
+        end
+
+        it "should set the Content-Length header" do
+          @response.expects(:[]=).with("Content-Length", 100)
+
+          @handler.set_response(@response, @file, 200)
+        end
+
+        it "should return a RackFile adapter as body" do
+          @response.expects(:body=).with { |val| val.is_a?(Puppet::Network::HTTP::RackREST::RackFile) }
+
+          @handler.set_response(@response, @file, 200)
+        end
+      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)
+        result[:foo].should == "baz"
+        result[:bar].should == "xyzzy"
+      end
+
+      it "should CGI-decode the HTTP parameters" do
+        encoding = CGI.escape("foo bar")
+        req = mk_req("/?foo=#{encoding}")
+        result = @handler.params(req)
+        result[:foo].should == "foo bar"
+      end
+
+      it "should convert the string 'true' to the boolean" do
+        req = mk_req("/?foo=true")
+        result = @handler.params(req)
+        result[:foo].should be_true
+      end
+
+      it "should convert the string 'false' to the boolean" do
+        req = mk_req("/?foo=false")
+        result = @handler.params(req)
+        result[:foo].should be_false
+      end
+
+      it "should convert integer arguments to Integers" do
+        req = mk_req("/?foo=15")
+        result = @handler.params(req)
+        result[:foo].should == 15
+      end
+
+      it "should convert floating point arguments to Floats" do
+        req = mk_req("/?foo=1.5")
+        result = @handler.params(req)
+        result[:foo].should == 1.5
+      end
+
+      it "should YAML-load and CGI-decode values that are YAML-encoded" do
+        escaping = CGI.escape(YAML.dump(%w{one two}))
+        req = mk_req("/?foo=#{escaping}")
+        result = @handler.params(req)
+        result[:foo].should == %w{one two}
+      end
+
+      it "should not allow the client to set the node via the query string" do
+        req = mk_req("/?node=foo")
+        @handler.params(req)[:node].should be_nil
+      end
+
+      it "should not allow the client to set the IP address via the query string" do
+        req = mk_req("/?ip=foo")
+        @handler.params(req)[:ip].should be_nil
+      end
+
+      it "should pass the client's ip address to model find" do
+        req = mk_req("/", 'REMOTE_ADDR' => 'ipaddress')
+        @handler.params(req)[:ip].should == "ipaddress"
+      end
+
+      it "should set 'authenticated' to false if no certificate is present" do
+        req = mk_req('/')
+        @handler.params(req)[:authenticated].should be_false
+      end
+    end
+
+    describe "with pre-validated certificates" do
+
+      it "should use the :ssl_client_header to determine the parameter when looking for the certificate" do
+        Puppet.settings.stubs(:value).returns "eh"
+        Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
+        req = mk_req('/', "myheader" => "/CN=host.domain.com")
+        @handler.params(req)
+      end
+
+      it "should retrieve the hostname by matching the certificate parameter" do
+        Puppet.settings.stubs(:value).returns "eh"
+        Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
+        req = mk_req('/', "myheader" => "/CN=host.domain.com")
+        @handler.params(req)[:node].should == "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.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
+        Puppet.settings.expects(:value).with(:ssl_client_verify_header).returns "myheader"
+        req = mk_req('/', "myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
+        @handler.params(req)
+      end
+
+      it "should consider the host authenticated if the validity parameter contains 'SUCCESS'" do
+        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
+        Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
+        req = mk_req('/', "myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
+        @handler.params(req)[:authenticated].should be_true
+      end
+
+      it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
+        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
+        Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
+        req = mk_req('/', "myheader" => "whatever", "certheader" => "/CN=host.domain.com")
+        @handler.params(req)[:authenticated].should be_false
+      end
+
+      it "should consider the host unauthenticated if no certificate information is present" do
+        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
+        Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
+        req = mk_req('/', "myheader" => nil, "certheader" => "/CN=host.domain.com")
+        @handler.params(req)[:authenticated].should be_false
+      end
+
+      it "should resolve the node name with an ip address look-up if no certificate is present" do
+        Puppet.settings.stubs(:value).returns "eh"
+        Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
+        req = mk_req('/', "myheader" => nil)
+        @handler.expects(:resolve_node).returns("host.domain.com")
+        @handler.params(req)[:node].should == "host.domain.com"
+      end
+    end
+  end
+end
+
+describe Puppet::Network::HTTP::RackREST::RackFile do
+  before(:each) do
+    stat = stub 'stat', :size => 100
+    @file = stub 'file', :stat => stat, :path => "/tmp/path"
+    @rackfile = Puppet::Network::HTTP::RackREST::RackFile.new(@file)
+  end
+
+  it "should have an each method" do
+    @rackfile.should be_respond_to(:each)
+  end
+
+  it "should yield file chunks by chunks" do
+    @file.expects(:read).times(3).with(8192).returns("1", "2", nil)
+    i = 1
+    @rackfile.each do |chunk|
+      chunk.to_i.should == i
+      i += 1
+    end
+  end
+
+  it "should have a close method" do
+    @rackfile.should be_respond_to(:close)
+  end
+
+  it "should delegate close to File close" do
+    @file.expects(:close)
+    @rackfile.close
+  end
+end