sinatra-api 1.0.2 → 1.1.2

data/lib/sinatra/api/resource_aliases.rb

@@ -17,7 +17,7 @@ module Sinatra
         return if key.to_s == resource_alias
 
         self.resource_aliases[key] << resource_alias
-        logger.debug "API resource #{original} is now aliased as #{resource_alias}"
+        # logger.debug "API resource #{original} is now aliased as #{resource_alias}"
       end
 
       def aliases_for(resource)

data/lib/sinatra/api/resources.rb

@@ -24,6 +24,22 @@ module Sinatra::API
   # and optional validators.
   #
   module Resources
+
+    def self.included(app)
+      app.set(:requires) do |*resources|
+        condition do
+          @required = resources.collect { |r| r.to_s }
+          @required.each do |r|
+            @parent_resource = api_locate_resource(r, @parent_resource)
+          end
+        end
+      end
+
+      Sinatra::API.on :request do |instance|
+        @parent_resource = nil
+      end
+    end
+
     private
 
     # Attempt to locate a resource based on an ID supplied in a request parameter.
@@ -32,8 +48,9 @@ module Sinatra::API
     # we attempt to locate and expose it to the route.
     #
     # A 404 is raised if:
-    #   1. the scope is missing (@space for folder, @space or @folder for page)
-    #   2. the resource couldn't be identified in its scope (@space or @folder)
+    #
+    #   1. the scope is missing
+    #   2. the resource couldn't be found in its scope
     #
     # If the resources were located, they're accessible using @folder or @page.
     #
@@ -41,6 +58,7 @@ module Sinatra::API
     # a resource.
     #
     # @example using :requires to reject a request with an invalid @page
+    #
     #   get '/folders/:folder_id/pages/:page_id', :requires => [ :page ] do
     #     @page.show    # page is good
     #     @folder.show  # so is its folder
@@ -55,7 +73,8 @@ module Sinatra::API
       else;                 container.send("#{r.to_plural}")
       end
 
-      puts "locating resource #{r} with id #{resource_id} from #{collection} [#{container}]"
+      Sinatra::API.logger.debug "locating resource #{r} with id #{resource_id} " +
+        "from #{collection} [#{container}]"
 
       resource = collection.get(resource_id)
 

data/lib/sinatra/api/version.rb

@@ -21,6 +21,6 @@
 
 module Sinatra
   module API
-    VERSION = "1.0.2"
+    VERSION = "1.1.2"
   end
 end

data/spec/helpers/api_calls.rb

@@ -0,0 +1,33 @@
+require 'spec/helpers/rack_test_api_response'
+require 'spec/helpers/rspec_api_response_matchers'
+
+# Converts a Rack::Test HTTP mock response into an API one.
+#
+# @see Rack::Test::APIResponse
+#
+# @example usage
+#   rc = api_call get '/api/endpoint'
+#   rc.should fail(400, 'some error explanation')
+#   rc.should succeed(201)
+#   rc.messages.empty?.should be_true
+#   rc.status.should == :error
+#
+# @example using expect {}
+#   expect { api_call get '/foobar' }.to succeed(200)
+def api_call(rack_response)
+  Rack::Test::APIResponse.new(rack_response)
+end
+
+# Does the same thing as #api_call but wraps it into a block.
+#
+# @example usage
+#   api { get '/api/endpoint' }.should fail(403, 'not authorized')
+#
+# @see #api_call
+def api(&block)
+  api_call(block.yield)
+end
+
+RSpec.configure do |config|
+  config.include RSpec::APIResponseMatchers
+end

data/spec/helpers/rack_test_api_response.rb

@@ -0,0 +1,45 @@
+module Rack
+  module Test
+    class APIResponse
+      attr_reader :rr, :body, :status, :messages, :http_rc
+
+      def initialize(rack_response)
+        @rr       = rack_response
+        @http_rc  = @rr.status
+        begin;
+          @body = JSON.parse(@rr.body.empty? ? '{}' : @rr.body)
+          @body = @body.with_indifferent_access
+        rescue JSON::ParserError => e
+          raise "Invalid API response;" +
+            "body could not be parsed as JSON:\n#{@rr.body}\nException: #{e.message}"
+        end
+
+        @status   = :success
+        @messages = []
+
+        unless blank?
+          if @body.is_a?(Hash)
+            @status   = @body["status"].to_sym  if @body.has_key?("status")
+            @messages = @body["messages"]       if @body.has_key?("messages")
+          elsif @body.is_a?(Array)
+            @messages = @body
+          else
+            @messages = @body
+          end
+        end
+      end
+
+      def blank?
+        @body.empty?
+      end
+
+      def succeeded?
+        !blank? && @status == :success
+      end
+
+      def failed?
+        !blank? && @status == :error
+      end
+    end # APIResponse
+  end # Test
+end # Rack

data/spec/helpers/rspec_api_response_matchers.rb

@@ -0,0 +1,135 @@
+module RSpec
+  module APIResponseMatchers
+    class Fail
+      def initialize(http_rc = 400, *keywords)
+        @http_rc  = http_rc
+        @keywords = (keywords || []).flatten
+        @raw_keywords = @keywords.dup
+      end
+
+      def matches?(api_rc)
+        if api_rc.is_a?(Proc)
+          api_rc = api_rc.yield
+        end
+
+        @api_rc = api_rc
+
+        return false if api_rc.http_rc != @http_rc
+        return false if api_rc.status  != :error
+
+        if @keywords.empty?
+          return true if api_rc.messages.empty?
+          return false
+        end
+
+        if @keywords.size == 1
+          @keywords = @keywords.first.split(/\s/)
+        end
+
+        @keywords = Regexp.new(@keywords.join('.*'), 'i')
+
+        matched = false
+        api_rc.messages.each { |m|
+          if m.match(@keywords)
+            matched = true
+            break
+          end
+        }
+
+        matched
+      end # Fail#matches
+
+      def failure_message
+        m = "Expected: \n"
+
+        if @api_rc.status != :error
+          m << "* The API response status to be :error, but got #{@api_rc.status}\n"
+        end
+
+        if @api_rc.http_rc != @http_rc
+          m << "* The HTTP RC to be #{@http_rc}, but got #{@api_rc.http_rc}\n"
+        end
+
+        formatted_keywords = @raw_keywords.join(' ')
+
+        if @raw_keywords.any? && @api_rc.messages.any?
+          m << "* One of the following API response messages: \n"
+          m << @api_rc.messages.collect.with_index { |m, i| "\t#{i+1}. #{m}" }.join("\n")
+          m << "\n  to be matched by the keywords: #{formatted_keywords}\n"
+
+        elsif @raw_keywords.any? && @api_rc.messages.empty?
+          m << "* The API response to contain some messages (got 0) and for at least\n" <<
+               "  one of them to match the keywords #{formatted_keywords}\n"
+
+        elsif @raw_keywords.empty? && @api_rc.messages.any?
+          m << "* The API response to contain no messages, but got: \n"
+          m << @api_rc.messages.collect.with_index { |m, i| "\t#{i+1}. #{m}" }.join("\n")
+          m << "\n"
+        end
+
+        m
+      end
+
+      # def negative_failure_message
+      #   "expected API response [status:#{@api_rc.status}] not to be :error, " <<
+      #   "and API response [messages: #{@api_rc.messages}] not to match '#{@keywords}'"
+      # end
+    end # Fail
+
+    class Success
+      def initialize(http_rc)
+        @http_rc = http_rc
+      end
+
+      def matches?(api_rc)
+        if api_rc.is_a?(Proc)
+          api_rc = api_rc.yield
+        end
+
+        @api_rc = api_rc
+
+        return false unless @http_rc.include?(api_rc.http_rc)
+        return false if api_rc.status  != :success
+
+        true
+      end
+
+      def failure_message
+        m = "Expected:\n"
+
+        if @api_rc.status != :success
+          m << "* The API response status to be :success, but got #{@api_rc.status}\n"
+        end
+
+        if @api_rc.http_rc != @http_rc
+          m << "* The HTTP RC to be #{@http_rc}, but got #{@api_rc.http_rc}\n"
+        end
+
+        if @api_rc.messages.any?
+          m << "* The API response messages to be empty, but got: \n"
+          m << @api_rc.messages.collect.with_index { |m, i| "\t#{i+1}. #{m}" }.join("\n")
+          m << "\n"
+        end
+
+        m
+      end
+
+      # def negative_failure_message
+      #   m = "expected API response [status:#{@api_rc.status}] not to be :success"
+      #   if @api_rc.messages.any?
+      #     m << ", and no messages, but got: #{@api_rc.messages}"
+      #   end
+      #   m
+      # end
+    end
+
+    def fail(http_rc = 400, *keywords)
+      Fail.new(http_rc, keywords)
+    end
+
+    def succeed(http_rc = 200..205)
+      http_rc = http_rc.respond_to?(:to_a) ? http_rc.to_a : [ http_rc ]
+      Success.new(http_rc.flatten)
+    end
+  end
+end

data/spec/integration/parameter_validators/float_validator_spec.rb

@@ -0,0 +1,85 @@
+describe Sinatra::API::FloatValidator do
+  include_examples 'integration specs'
+
+  it 'should accept a float' do
+    app.post '/' do
+      api_parameter! :rate, required: true, type: :float
+      api_params.to_json
+    end
+
+    rc = api_call post '/', { rate: 5.75 }.to_json
+    rc.should succeed
+    rc.body[:rate].should == 5.75
+  end
+
+  it 'should accept a float with scientific notation' do
+    app.post '/' do
+      api_parameter! :rate, required: true, type: :float
+      api_params.to_json
+    end
+
+    rc = api_call post '/', { rate: 5.75e3 }.to_json
+    rc.should succeed
+    rc.body[:rate].should == 5.75e3
+  end
+
+  it 'should accept a really big decimal' do
+    app.post '/' do
+      api_parameter! :rate, required: true, type: :float
+      api_params.to_json
+    end
+
+    rc = api_call post '/', { rate: 123456789.75e24 }.to_json
+    rc.should succeed
+    rc.body[:rate].should == 123456789.75e24
+  end
+
+  it 'should accept an integer' do
+    app.post '/' do
+      api_parameter! :rate, required: true, type: :float
+      api_params.to_json
+    end
+
+    rc = api_call post '/', { rate: 5 }.to_json
+    rc.should succeed
+    rc.body[:rate].should == 5.0
+  end
+
+  it 'should reject a non-numeric value' do
+    app.post '/' do
+      api_parameter! :rate, required: true, type: :float
+      api_params.to_json
+    end
+
+    rc = api_call post '/', { rate: 'asdf' }.to_json
+    rc.should fail(400, 'not a valid float')
+
+    rc = api_call post '/', { rate: [] }.to_json
+    rc.should fail(400, 'not a valid float')
+
+    rc = api_call post '/', { rate: {} }.to_json
+    rc.should fail(400, 'not a valid float')
+  end
+
+  it 'should coerce a float' do
+    app.post '/' do
+      api_parameter! :rate, required: true, type: :float
+      api_params.to_json
+    end
+
+    rc = api_call post '/', { rate: "5.8" }.to_json
+    rc.should succeed
+    rc.body[:rate].should == 5.8
+  end
+
+  it 'should not coerce a float' do
+    app.post '/' do
+      api_parameter! :rate, required: true, type: :float, coerce: false
+      api_params.to_json
+    end
+
+    rc = api_call post '/', { rate: "15.25" }.to_json
+    rc.should succeed
+    rc.body[:rate].should == "15.25"
+  end
+end

data/spec/integration/parameter_validators/integer_validator_spec.rb

@@ -0,0 +1,66 @@
+describe Sinatra::API::IntegerValidator do
+  include_examples 'integration specs'
+
+  it 'should accept a numeric value' do
+    app.post '/' do
+      api_parameter! :rate, required: true, type: :integer
+      api_params.to_json
+    end
+
+    rc = api_call post '/', { rate: 5 }.to_json
+    rc.should succeed
+    rc.body[:rate].should == 5
+  end
+
+  it 'should reject a non-numeric value' do
+    app.post '/' do
+      api_parameter! :rate, required: true, type: :integer
+      api_params.to_json
+    end
+
+    rc = api_call post '/', { rate: 'asdf' }.to_json
+    rc.should fail(400, 'not a valid integer')
+
+    rc = api_call post '/', { rate: '5.73' }.to_json
+    rc.should fail(400, 'not a valid integer')
+
+    rc = api_call post '/', { rate: [] }.to_json
+    rc.should fail(400, 'not a valid integer')
+
+    rc = api_call post '/', { rate: {} }.to_json
+    rc.should fail(400, 'not a valid integer')
+  end
+
+  it 'should round a float' do
+    app.post '/' do
+      api_parameter! :rate, required: true, type: :integer
+      api_params.to_json
+    end
+
+    rc = api_call post '/', { rate: 5.75 }.to_json
+    rc.should succeed
+    rc.body[:rate].should == 5
+  end
+
+  it 'should coerce an integer' do
+    app.post '/' do
+      api_parameter! :rate, required: true, type: :integer
+      api_params.to_json
+    end
+
+    rc = api_call post '/', { rate: "15" }.to_json
+    rc.should succeed
+    rc.body[:rate].should == 15
+  end
+
+  it 'should not coerce an integer' do
+    app.post '/' do
+      api_parameter! :rate, required: true, type: :integer, coerce: false
+      api_params.to_json
+    end
+
+    rc = api_call post '/', { rate: "15" }.to_json
+    rc.should succeed
+    rc.body[:rate].should == "15"
+  end
+end

data/spec/integration/parameter_validators/string_validator_spec.rb

@@ -0,0 +1,25 @@
+describe Sinatra::API::StringValidator do
+  include_examples 'integration specs'
+
+  it 'should accept a string value' do
+    app.get '/' do
+      api_parameter! :name, required: true, type: :string
+      api_parameter :name
+    end
+
+    get '/', { name: 'foo' }
+    last_response.status.should == 200
+    last_response.body.should == 'foo'
+  end
+
+  it 'should reject a non-string value' do
+    app.post '/' do
+      api_parameter! :name, required: true, type: :string
+      api_parameter :name
+    end
+
+    rc = api_call post '/', { name: 5 }.to_json
+    rc.should fail(400, '')
+    rc.body[:field_errors][:name].should match(/expected.*string/i)
+  end
+end