sinatra-rest-addons 0.1.4 → 1.0.0

data/VERSION

@@ -1 +1 @@
-0.1.4
+1.0.0

data/lib/sinatra/rest/helpers.rb

@@ -6,11 +6,103 @@ module Sinatra
     #   class App < Sinatra::Base
     #     helpers Sinatra::REST::Helpers
     #   end
-    module Helpers    
+    module Helpers  
+      
+      INFINITY = 1/0.0
+        
       def compute_etag(*args)
         raise ArgumentError, "You must provide at least one parameter for the ETag computation" if args.empty?
         Digest::SHA1.hexdigest(args.join("."))
       end
+      
+      # e.g.
+      #   get '/' do
+      #     provides :xml, "text/html;level=5"
+      #     "Hello"
+      #   end
+      # will accept requests having an Accept header containing at least one of the following value:
+      # * application/xml
+      # * application/*
+      # * text/html
+      # * text/html;level=5
+      # * text/html;level=6
+      def provides(*formats)
+        generate_type_hash = Proc.new{ |header| 
+          type, *params = header.split(/;\s*/)
+          Hash[*params.map{|p| p.split(/\s*=\s*/)}.flatten].merge("type" => type)
+        }
+        supported_formats = formats.map do |f| 
+          # selects the correct mime type if a symbol is given
+          f.is_a?(Symbol) ? ::Rack::Mime::MIME_TYPES[".#{f.to_s}"] : f
+        end.compact.map do |f|
+          generate_type_hash.call(f)
+        end
+        # request.accept is an Array
+        accepted_formats = request.accept.map do |f| 
+          generate_type_hash.call(f)
+        end
+        selected_format = nil
+        accepted_formats.each{ |accepted_format| 
+          selected_format = supported_formats.detect{ |supported_format| 
+            Regexp.new(Regexp.escape(accepted_format["type"]).gsub("\\*", ".*?"), Regexp::IGNORECASE) =~ supported_format["type"] &&
+              (accepted_format["level"] || INFINITY).to_f >= (supported_format["level"] || 0).to_f
+          }
+          break unless selected_format.nil?
+        } 
+        if selected_format.nil?
+          content_type :txt
+          halt 406, supported_formats.map{|f| 
+            output = f["type"]
+            output.concat(";level=#{f["level"]}") if f.has_key?("level")
+            output
+          }.join(",")
+        else
+          response.headers['Content-Type'] = "#{selected_format["type"]}#{selected_format["level"].nil? ? "" : ";level=#{selected_format["level"]}"}"
+        end
+      end # def provides
+
+
+      # Automatically decode the input data (coming from a POST or PUT request) based on the request's content-type.
+      # You must pass a Proc that will return the parser object to use to decode the payload.
+      # The parser object must respond to a <tt>parse</tt> method.
+      # You may also pass a hash of options:
+      # * <tt>:size_range</tt>: byte range specifying the minimum and maximum length (in bytes) of the payload [default=(1..1024**3)]
+      # 
+      # e.g.
+      #   post  '/resource' do
+      #     data = decode lambda{|content_type| if content_type =~ /^application\/.*json$/i then JSON}, :size_range => (1..2*1024**3)
+      #   end
+      # 
+      # The processing of the request will be halted in the following cases:
+      # * 400 if the payload is not within the specified size range.
+      # * 400 if the payload cannot be correctly parsed.
+      # * 415 if the payload's content type is not supported (i.e. the given Proc returns nil)
+      # 
+      def decode(proc, config = {})
+        raise ArgumentError, "You must pass an object that responds to #call" unless proc.respond_to?(:call)
+        size_range = config.delete(:size_range) || (1..(1024**3))
+        case (mime_type = request.env['CONTENT_TYPE'])
+        when /^application\/x-www-form-urlencoded/i
+          request.env['sinatra.decoded_input'] = request.env['rack.request.form_hash']
+        else
+          content = ""
+          request.env['rack.input'].each do |block|
+            content.concat(block)
+            break if content.length > size_range.end
+          end
+          if not size_range.include?(content.length)
+            halt 400, "Input data size must be between #{size_range.begin} and #{size_range.end} bytes."
+          elsif parser = proc.call(mime_type)
+            begin
+              parser.parse(content)
+            rescue StandardError => e  
+              halt 400, "#{e.class.name}: #{e.message}"
+            end
+          else
+            halt 415, "Format #{mime_type} not supported"
+          end
+        end
+      end # def decode
     end # module Helpers
   end # module REST
 end # module Sinatra

data/lib/sinatra/rest/routes.rb

@@ -11,51 +11,6 @@ module Sinatra
       
       # Allow the definition of OPTIONS routes
       def options(path, opts={}, &bk);   route 'OPTIONS',   path, opts, &bk end
-      
-      # e.g.
-      #   get '/', :provides => [:xml, "text/html;level=5"] { "hello" }
-      # will accept requests with Accept header =
-      # * application/xml
-      # * application/*
-      # * text/html
-      # * text/html;level=5
-      # * text/html;level=6
-      def provides(*formats)
-        generate_type_hash = Proc.new{ |header| 
-          type, *params = header.split(/;\s*/)
-          Hash[*params.map{|p| p.split(/\s*=\s*/)}.flatten].merge("type" => type)
-        }
-        condition {
-          supported_formats = formats.map do |f| 
-            # selects the correct mime type if a symbol is given
-            f.is_a?(Symbol) ? ::Rack::Mime::MIME_TYPES[".#{f.to_s}"] : f
-          end.compact.map do |f|
-            generate_type_hash.call(f)
-          end
-          # request.accept is an Array
-          accepted_formats = request.accept.map do |f| 
-            generate_type_hash.call(f)
-          end
-          selected_format = nil
-          accepted_formats.each{ |accepted_format| 
-            selected_format = supported_formats.detect{ |supported_format| 
-              Regexp.new(Regexp.escape(accepted_format["type"]).gsub("\\*", ".*?"), Regexp::IGNORECASE) =~ supported_format["type"] &&
-                (accepted_format["level"] || INFINITY).to_f >= (supported_format["level"] || 0).to_f
-            }
-            break unless selected_format.nil?
-          } 
-          if selected_format.nil?
-            content_type :txt
-            halt 406, supported_formats.map{|f| 
-              output = f["type"]
-              output.concat(";level=#{f["level"]}") if f.has_key?("level")
-              output
-            }.join(",")
-          else
-            response.headers['Content-Type'] = "#{selected_format["type"]}#{selected_format["level"].nil? ? "" : ";level=#{selected_format["level"]}"}"
-          end
-        }
-      end # def provides
     
       # Allow access to the route based on the result of the given proc, whose argument is a <tt>credentials</tt> object.
       # You MUST declare a helper function named <tt>credentials</tt> that will return an object (of your choice) containing the client's credentials, 
@@ -76,46 +31,6 @@ module Sinatra
           end
         }
       end # def allow
-    
-      # Automatically decode the input data (coming from a POST or PUT request) based on the request's content-type.
-      # First argument must be a parsing procedure that will be used to parse the input data according to its content type.
-      # The decoded input will be available in request.env['sinatra.decoded_input']
-      # e.g.
-      #   post  '/', 
-      #         :decode => Proc.new{ |content_type, content| 
-      #           content_type =~ /^application\/.*json$/i ? JSON.parse(content) : throw(:halt, [400, "Don't know how to parse '#{content_type}' content."])
-      #         } do 
-      #     "#{request.env['sinatra.decoded_input']}"
-      #   end
-      def decode(*args)
-        args = [args] unless args.kind_of? Array
-        parsing_proc  = args.shift
-        raise ArgumentError, "You must provide a proc to parse the input data" unless parsing_proc.kind_of?(Proc)
-        size_range    = args.shift || (1..(1024**3))
-        condition {
-          begin
-            case (mime_type = request.env['CONTENT_TYPE'])
-            when /^application\/x-www-form-urlencoded/i
-              request.env['sinatra.decoded_input'] = request.env['rack.request.form_hash']
-            else
-              content = ""
-              request.env['rack.input'].each do |block|
-                content.concat(block)
-                break if content.length > size_range.end
-              end
-              if not size_range.include?(content.length)
-                content_type :txt
-                halt 400, "Input data size must be between #{size_range.begin} and #{size_range.end} bytes."
-              else
-                request.env['sinatra.decoded_input'] = parsing_proc.call(mime_type, content)
-              end
-            end
-          rescue StandardError => e  
-            content_type :txt
-            halt 400, "#{e.class.name}: #{e.message}"
-          end
-        }
-      end # def decode
       
     end # module Routes
   end # module REST

data/sinatra-rest-addons.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{sinatra-rest-addons}
-  s.version = "0.1.4"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Cyril Rohr"]
-  s.date = %q{2009-11-23}
+  s.date = %q{2010-01-07}
   s.description = %q{A set of helpers and extensions for sinatra apps that expose REST resources.}
   s.email = %q{cyril.rohr@gmail.com}
   s.extra_rdoc_files = [
@@ -26,6 +26,7 @@ Gem::Specification.new do |s|
      "lib/sinatra/rest/routes.rb",
      "sinatra-rest-addons.gemspec",
      "test/helper.rb",
+     "test/test_helpers.rb",
      "test/test_routes.rb"
   ]
   s.homepage = %q{http://github.com/crohr/sinatra-rest-addons}
@@ -35,6 +36,7 @@ Gem::Specification.new do |s|
   s.summary = %q{A set of helpers and extensions for sinatra apps that expose REST resources.}
   s.test_files = [
     "test/helper.rb",
+     "test/test_helpers.rb",
      "test/test_routes.rb"
   ]
 

data/test/test_helpers.rb

@@ -0,0 +1,182 @@
+require File.dirname(__FILE__) + '/helper'
+require 'json'
+
+class HelpersTest < Test::Unit::TestCase
+  
+  context "helper :provides" do
+  
+    test "should return 406 and the list of supported types, if the server does not support the types accepted by the client [simple matching]" do
+      mock_app {
+        helpers Sinatra::REST::Helpers
+        get '/' do
+          provides "application/xml", "application/vnd.x.y.z+xml"
+          request.env['HTTP_ACCEPT']
+        end
+      }
+      get '/', {}, { 'HTTP_ACCEPT' => 'application/json' }
+      assert_equal 406, last_response.status
+      assert_equal 'application/xml,application/vnd.x.y.z+xml', last_response.body
+      assert_equal 'text/plain', last_response.headers['Content-Type']
+    end
+    test "should return 406 if the accepted type has a level lower than what is supported" do
+      mock_app {
+        helpers Sinatra::REST::Helpers
+        get '/' do
+          provides "application/xml;level=5"
+          request.env['HTTP_ACCEPT']
+        end
+      }
+      get '/', {}, { 'HTTP_ACCEPT' => 'application/xml;level=4' }
+      assert_equal 406, last_response.status
+      assert_equal 'application/xml;level=5', last_response.body
+      assert_equal 'text/plain', last_response.headers['Content-Type']
+    end
+    test "should return the first matching type if the accepted type contains a *" do
+      mock_app {
+        helpers Sinatra::REST::Helpers
+        get '/' do
+          provides "application/xml", "application/vnd.x.y.z+xml"
+          request.env['HTTP_ACCEPT']
+        end
+      }
+      get '/', {}, { 'HTTP_ACCEPT' => 'application/*' }
+      assert_equal 200, last_response.status
+      assert_equal 'application/*', last_response.body
+      assert_equal 'application/xml', last_response.headers['Content-Type']
+    end
+    test "should respect the order in which the accepted formats are declared when looking for the format to select" do
+      mock_app {
+        helpers Sinatra::REST::Helpers
+        get '/' do
+          provides "application/json", "application/xml", "application/vnd.x.y.z+xml"
+          request.env['HTTP_ACCEPT']
+        end
+      }
+      get '/', {}, { 'HTTP_ACCEPT' => 'application/xml, */*' }
+      assert_equal 200, last_response.status
+      assert_equal 'application/xml, */*', last_response.body
+      assert_equal 'application/xml', last_response.headers['Content-Type']
+    end
+    test "should be successful if the accepted type does not require a specific level" do
+      mock_app {
+        helpers Sinatra::REST::Helpers
+        get '/' do
+          provides "application/xml;level=5"
+          request.env['HTTP_ACCEPT']
+        end
+      }
+      get '/', {}, { 'HTTP_ACCEPT' => 'application/xml' }
+      assert last_response.ok?
+      assert_equal 'application/xml', last_response.body
+      assert_equal 'application/xml;level=5', last_response.headers['Content-Type']
+    end
+    test "should be successful if the accepted type level is greater than what is supported" do
+      mock_app {
+        helpers Sinatra::REST::Helpers
+        get '/' do
+          provides "application/xml;level=5"
+          request.env['HTTP_ACCEPT']
+        end
+      }
+      get '/', {}, { 'HTTP_ACCEPT' => 'application/xml;level=6' }
+      assert last_response.ok?
+      assert_equal 'application/xml;level=6', last_response.body
+      assert_equal 'application/xml;level=5', last_response.headers['Content-Type']
+    end
+  end
+  
+  context "helper :decode" do
+    setup do
+      PARSING_PROC = Proc.new{|content_type| content_type =~ /^application\/.*json$/i ? JSON : nil} unless defined?(PARSING_PROC)
+    end
+    test "should return 400 if the input content is empty" do
+      mock_app {
+        helpers Sinatra::REST::Helpers
+        post '/' do
+          data = decode PARSING_PROC
+        end
+        error 400 do
+          content_type :txt
+          "#{response.body.to_s}"
+        end
+      }
+      post '/', "", {'CONTENT_TYPE' => "application/json"}
+      assert_equal 400, last_response.status
+      assert_equal 'Input data size must be between 1 and 1073741824 bytes.', last_response.body
+      assert_equal 'text/plain', last_response.headers['Content-Type']
+    end
+    test "should return 400 if the input content is too large" do
+      mock_app {
+        helpers Sinatra::REST::Helpers
+        post '/' do
+          decode PARSING_PROC, :size_range => 2...30
+        end
+      }
+      post '/', '{"key1": ["value1", "value2"]}', {'CONTENT_TYPE' => "application/json"}
+      assert_equal 400, last_response.status
+      assert_equal 'Input data size must be between 2 and 30 bytes.', last_response.body
+    end
+    test "should return 400 if the input content can be parsed but is malformed" do
+      mock_app {
+        helpers Sinatra::REST::Helpers
+        post '/'do
+          decode PARSING_PROC, :size_range => 2...30
+        end
+      }
+      post '/', '{"key1": ["value1", "value2"]', {'CONTENT_TYPE' => "application/json"}
+      assert_equal 400, last_response.status
+      assert_equal "JSON::ParserError: 618: unexpected token at '{\"key1\": [\"value1\", \"value2\"]'", last_response.body
+    end
+    test "should return 415 if the parsing proc does not return a parser" do
+      mock_app {
+        helpers Sinatra::REST::Helpers
+        post '/' do
+          decode PARSING_PROC
+        end
+      }
+      post '/', '<item></item>', {'CONTENT_TYPE' => "application/xml"}
+      assert_equal 415, last_response.status
+      assert_equal "Format application/xml not supported", last_response.body
+    end
+    test "should correctly parse the input content if a parser can be found for the specified content type, and the decoded input must be returned" do
+      input = {"key1" => ["value1", "value2"]}
+      mock_app {
+        helpers Sinatra::REST::Helpers
+        post '/' do
+          data = decode PARSING_PROC, :size_range => 2...30
+          content_type 'application/json'
+          JSON.dump data
+        end
+      }
+      post '/', JSON.dump(input), {'CONTENT_TYPE' => "application/json"}
+      assert_equal 200, last_response.status
+      assert_equal JSON.dump(input), last_response.body
+      assert_equal 'application/json', last_response.headers['Content-Type']
+    end
+    test "should set the decoded input to the params hash already decoded by Sinatra, if the request's content type is application/x-www-form-urlencoded" do
+      input = {"key1" => ["value1", "value2"]}
+      mock_app {
+        helpers Sinatra::REST::Helpers
+        post '/' do
+          data = decode PARSING_PROC, :size_range => 2...30
+          content_type 'application/json'
+          JSON.dump data
+        end
+      }
+      post '/', input
+      assert_equal 200, last_response.status
+      assert_equal JSON.dump(input), last_response.body
+      assert_equal 'application/json', last_response.headers['Content-Type']
+    end
+    test "should raise an error if the first argument is not a proc" do
+     mock_app {
+        helpers Sinatra::REST::Helpers
+        post '/' do
+          decode :whatever
+        end
+      }
+      assert_raise(ArgumentError){ post '/' }
+    end
+  end
+  
+end

data/test/test_routes.rb

@@ -19,200 +19,6 @@ class RoutesTest < Test::Unit::TestCase
     assert_equal 'remove me', response.body
   end
   
-  context "route option :provides" do
-  
-    test "should return 406 and the list of supported types, if the server does not support the types accepted by the client [simple matching]" do
-      mock_app {
-        register Sinatra::REST::Routes
-        get '/', :provides => ["application/xml", "application/vnd.x.y.z+xml"] do
-          request.env['HTTP_ACCEPT']
-        end
-      }
-      get '/', {}, { 'HTTP_ACCEPT' => 'application/json' }
-      assert_equal 406, last_response.status
-      assert_equal 'application/xml,application/vnd.x.y.z+xml', last_response.body
-      assert_equal 'text/plain', last_response.headers['Content-Type']
-    end
-    test "should return 406 if the accepted type has a level lower than what is supported" do
-      mock_app {
-        register Sinatra::REST::Routes
-        get '/', :provides => ["application/xml;level=5"] do
-          request.env['HTTP_ACCEPT']
-        end
-      }
-      get '/', {}, { 'HTTP_ACCEPT' => 'application/xml;level=4' }
-      assert_equal 406, last_response.status
-      assert_equal 'application/xml;level=5', last_response.body
-      assert_equal 'text/plain', last_response.headers['Content-Type']
-    end
-    test "should return the first matching type if the accepted type contains a *" do
-      mock_app {
-        register Sinatra::REST::Routes
-        get '/', :provides => ["application/xml", "application/vnd.x.y.z+xml"] do
-          request.env['HTTP_ACCEPT']
-        end
-      }
-      get '/', {}, { 'HTTP_ACCEPT' => 'application/*' }
-      assert_equal 200, last_response.status
-      assert_equal 'application/*', last_response.body
-      assert_equal 'application/xml', last_response.headers['Content-Type']
-    end
-    test "should respect the order in which the accepted formats are declared when looking for the format to select" do
-      mock_app {
-        register Sinatra::REST::Routes
-        get '/', :provides => ["application/json", "application/xml", "application/vnd.x.y.z+xml"] do
-          request.env['HTTP_ACCEPT']
-        end
-      }
-      get '/', {}, { 'HTTP_ACCEPT' => 'application/xml, */*' }
-      assert_equal 200, last_response.status
-      assert_equal 'application/xml, */*', last_response.body
-      assert_equal 'application/xml', last_response.headers['Content-Type']
-    end
-    test "should be successful if the accepted type does not require a specific level" do
-      mock_app {
-        register Sinatra::REST::Routes
-        get '/', :provides => ["application/xml;level=5"] do
-          request.env['HTTP_ACCEPT']
-        end
-      }
-      get '/', {}, { 'HTTP_ACCEPT' => 'application/xml' }
-      assert last_response.ok?
-      assert_equal 'application/xml', last_response.body
-      assert_equal 'application/xml;level=5', last_response.headers['Content-Type']
-    end
-    test "should be successful if the accepted type level is greater than what is supported" do
-      mock_app {
-        register Sinatra::REST::Routes
-        get '/', :provides => ["application/xml;level=5"] do
-          request.env['HTTP_ACCEPT']
-        end
-      }
-      get '/', {}, { 'HTTP_ACCEPT' => 'application/xml;level=6' }
-      assert last_response.ok?
-      assert_equal 'application/xml;level=6', last_response.body
-      assert_equal 'application/xml;level=5', last_response.headers['Content-Type']
-    end
-  end
-  
-  context "route option :decode" do
-    setup do
-      PARSING_PROC = Proc.new{|content_type, content| content_type =~ /^application\/.*json$/i ? JSON.parse(content) : throw(:halt, [400, "Cannot parse"])} unless defined? PARSING_PROC
-    end
-    test "should return 400 if the input content is empty" do
-      mock_app {
-        register Sinatra::REST::Routes
-        post '/', :decode => PARSING_PROC do
-          request.env['sinatra.decoded_input'].inspect
-        end
-      }
-      post '/', "", {'CONTENT_TYPE' => "application/json"}
-      assert_equal 400, last_response.status
-      assert_equal 'Input data size must be between 1 and 1073741824 bytes.', last_response.body
-      assert_equal 'text/plain', last_response.headers['Content-Type']
-    end
-    test "should return 400 if the input content is too large" do
-      mock_app {
-        register Sinatra::REST::Routes
-        post '/', :decode => [PARSING_PROC, 2...30] do
-          request.env['sinatra.decoded_input'].inspect
-        end
-      }
-      post '/', '{"key1": ["value1", "value2"]}', {'CONTENT_TYPE' => "application/json"}
-      assert_equal 400, last_response.status
-      assert_equal 'Input data size must be between 2 and 30 bytes.', last_response.body
-      assert_equal 'text/plain', last_response.headers['Content-Type']
-    end
-    test "should return 400 if the input content can be parsed but is malformed" do
-      mock_app {
-        register Sinatra::REST::Routes
-        post '/', :decode => [PARSING_PROC, 2..30] do
-          request.env['sinatra.decoded_input'].inspect
-        end
-      }
-      post '/', '{"key1": ["value1", "value2"]', {'CONTENT_TYPE' => "application/json"}
-      assert_equal 400, last_response.status
-      assert_equal "JSON::ParserError: 618: unexpected token at '{\"key1\": [\"value1\", \"value2\"]'", last_response.body
-      assert_equal 'text/plain', last_response.headers['Content-Type']
-    end
-    test "should allow the parsing proc to throw an exception if needed (e.g. no parser can be found for the requested content type)" do
-      mock_app {
-        register Sinatra::REST::Routes
-        post '/', :decode => [PARSING_PROC, 2..30] do
-          request.env['sinatra.decoded_input'].inspect
-        end
-      }
-      post '/', '<item></item>', {'CONTENT_TYPE' => "application/xml"}
-      assert_equal 400, last_response.status
-      assert_equal "Cannot parse", last_response.body
-      assert_equal 'text/html', last_response.headers['Content-Type']
-    end
-    test "should correctly parse the input content if a parser can be found for the specified content type, and the decoded input must be made available in env['sinatra.decoded_input']" do
-      input = {"key1" => ["value1", "value2"]}
-      mock_app {
-        register Sinatra::REST::Routes
-        post '/', :decode => [PARSING_PROC, 2...30] do
-          content_type 'application/json'
-          JSON.dump request.env['sinatra.decoded_input']
-        end
-      }
-      post '/', JSON.dump(input), {'CONTENT_TYPE' => "application/json"}
-      assert_equal 200, last_response.status
-      assert_equal JSON.dump(input), last_response.body
-      assert_equal 'application/json', last_response.headers['Content-Type']
-    end
-    test "should work" do
-      input = "{\"walltime\":3600,\"resources\":\"/nodes=1\",\"at\":1258552306,\"on_launch\":{\"in\":\"/home/crohr\",\"do\":\"id\"}}" 
-      mock_app {
-        register Sinatra::REST::Routes
-        post '/', :decode => [PARSING_PROC, 2...3000] do
-          content_type 'application/json'
-          JSON.dump request.env['sinatra.decoded_input']
-        end
-      }
-      post '/', input, {'CONTENT_TYPE' => "application/json"}
-      p last_response.body
-      assert_equal 200, last_response.status
-      assert_equal JSON.parse(input), JSON.parse(last_response.body)
-      assert_equal 'application/json', last_response.headers['Content-Type']
-    end
-    test "should set the decoded input to the params hash already decoded by Sinatra, if the request's content type is application/x-www-form-urlencoded" do
-      input = {"key1" => ["value1", "value2"]}
-      mock_app {
-        register Sinatra::REST::Routes
-        post '/', :decode => [PARSING_PROC, 2...30] do
-          content_type 'application/json'
-          JSON.dump request.env['sinatra.decoded_input']
-        end
-      }
-      post '/', input
-      assert_equal 200, last_response.status
-      assert_equal JSON.dump(input), last_response.body
-      assert_equal 'application/json', last_response.headers['Content-Type']
-    end
-    test "should return 400 if the parsing proc raises a StandardError" do
-      mock_app {
-        register Sinatra::REST::Routes
-        post '/', :decode => Proc.new{|content_type, content| raise(StandardError, "error message") } do
-          request.env['sinatra.decoded_input'].inspect
-        end
-      }
-      post '/', 'whatever content', {'CONTENT_TYPE' => "whatever type"}
-      assert_equal 400, last_response.status
-      assert_equal "StandardError: error message", last_response.body
-      assert_equal 'text/plain', last_response.headers['Content-Type']
-    end
-    test "should raise an error if the first argument is not a proc" do
-     assert_raise(ArgumentError){ mock_app {
-        register Sinatra::REST::Routes
-        disable :raise_errors, :show_exceptions
-        post '/', :decode => :whatever do
-          JSON.dump request.env['sinatra.decoded_input']
-        end
-      } }
-    end
-  end
-  
   context "route option :allow" do
     test "should return 403 if the proc returns false" do
       mock_app {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sinatra-rest-addons
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 1.0.0
 platform: ruby
 authors: 
 - Cyril Rohr
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-23 00:00:00 +01:00
+date: 2010-01-07 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -51,6 +51,7 @@ files:
 - lib/sinatra/rest/routes.rb
 - sinatra-rest-addons.gemspec
 - test/helper.rb
+- test/test_helpers.rb
 - test/test_routes.rb
 has_rdoc: true
 homepage: http://github.com/crohr/sinatra-rest-addons
@@ -82,4 +83,5 @@ specification_version: 3
 summary: A set of helpers and extensions for sinatra apps that expose REST resources.
 test_files: 
 - test/helper.rb
+- test/test_helpers.rb
 - test/test_routes.rb