grape 0.1.1 → 2.4.0

data/spec/grape/middleware/auth/oauth2_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-describe Grape::Middleware::Auth::OAuth2 do
-  class FakeToken
-    def self.verify(token)
-      FakeToken.new(token) if %w(g e).include?(token[0..0])
-    end
-    
-    def initialize(token)
-      self.token = token
-    end
-    
-    def expired?
-      self.token[0..0] == 'e'
-    end
-    
-    def permission_for?(env)
-      env['PATH_INFO'] == '/forbidden' ? false : true
-    end
-    
-    attr_accessor :token
-  end
-
-  def app
-    Rack::Builder.app do
-      use Grape::Middleware::Auth::OAuth2, :token_class => 'FakeToken'
-      run lambda{|env| [200, {}, [ (env['api.token'].token rescue '') ]]}
-    end
-  end
-  
-  context 'with the token in the query string' do
-    context 'and a valid token' do
-      before { get '/awesome?oauth_token=g123' }
-      
-      it 'should set env["api.token"]' do
-        last_response.body.should == 'g123'
-      end
-    end
-    
-    context 'and an invalid token' do
-      before do
-        @err = catch :error do
-          get '/awesome?oauth_token=b123'
-        end
-      end
-      
-      it 'should throw an error' do
-        @err[:status].should == 401
-      end
-      
-      it 'should set the WWW-Authenticate header in the response' do
-        @err[:headers]['WWW-Authenticate'].should == "OAuth realm='OAuth API', error='invalid_token'"
-      end
-    end
-  end
-  
-  context 'with an expired token' do
-    before do
-      @err = catch :error do
-        get '/awesome?oauth_token=e123'
-      end
-    end
-    
-    it { @err[:status].should == 401 }
-    it { @err[:headers]['WWW-Authenticate'].should == "OAuth realm='OAuth API', error='expired_token'" }
-  end
-  
-  context 'with the token in the header' do
-    before { get '/awesome', {}, 'Authorization' => 'OAuth g123' }
-    it { last_response.body.should == 'g123' }
-  end
-  
-  context 'with the token in the POST body' do
-    before { post '/awesome', {'oauth_token' => 'g123'} }
-    it { last_response.body.should == 'g123'}
-  end
-  
-  context 'when accessing something outside its scope' do
-    before do
-      @err = catch :error do
-        get '/forbidden?oauth_token=g123'
-      end
-    end
-    
-    it { @err[:headers]['WWW-Authenticate'].should == "OAuth realm='OAuth API', error='insufficient_scope'" }
-    it { @err[:status].should == 403 }
-  end
-end

data/spec/grape/middleware/base_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-describe Grape::Middleware::Base do
-  subject { Grape::Middleware::Base.new(blank_app) }  
-  let(:blank_app) { lambda{|env| [200, {}, 'Hi there.']} }
-  
-  before do
-    # Keep it one object for testing.
-    subject.stub!(:dup).and_return(subject)
-  end
-  
-  it 'should have the app as an accessor' do
-    subject.app.should == blank_app
-  end
-  
-  it 'should be able to access the request' do
-    subject.call({})
-    subject.request.should be_kind_of(Rack::Request)
-  end
-  
-  it 'should call through to the app' do
-    subject.call({}).should == [200, {}, 'Hi there.']
-  end
-  
-  context 'callbacks' do
-    it 'should call #before' do
-      subject.should_receive(:before)
-    end
-  
-    it 'should call #after' do
-      subject.should_receive(:after)
-    end
-    
-    after{ subject.call!({}) }
-  end
-  
-  it 'should be able to access the response' do
-    subject.call({})
-    subject.response.should be_kind_of(Rack::Response)
-  end
-  
-  context 'options' do
-    it 'should persist options passed at initialization' do
-      Grape::Middleware::Base.new(blank_app, {:abc => true}).options[:abc].should be_true
-    end
-    
-    context 'defaults' do
-      class ExampleWare < Grape::Middleware::Base
-        def default_options
-          {:monkey => true}
-        end
-      end
-      
-      it 'should persist the default options' do
-        ExampleWare.new(blank_app).options[:monkey].should be_true
-      end
-      
-      it 'should override default options when provided' do
-        ExampleWare.new(blank_app, :monkey => false).options[:monkey].should be_false
-      end
-    end
-  end
-end

data/spec/grape/middleware/error_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe Grape::Middleware::Error do
-  class ErrApp
-    class << self    
-      attr_accessor :error
-      attr_accessor :format
-      
-      def call(env)
-        throw :error, self.error
-      end
-    end
-  end
-  
-  def app
-    Rack::Builder.app do
-      use Grape::Middleware::Error, :default_message => 'Aww, hamburgers.'
-      run ErrApp
-    end
-  end
-  
-  it 'should set the status code appropriately' do
-    ErrApp.error = {:status => 410}
-    get '/'
-    last_response.status.should == 410
-  end
-  
-  it 'should set the error message appropriately' do
-    ErrApp.error = {:message => 'Awesome stuff.'}
-    get '/'
-    last_response.body.should == 'Awesome stuff.'
-  end
-  
-  it 'should default to a 403 status' do
-    ErrApp.error = {}
-    get '/'
-    last_response.status.should == 403
-  end
-  
-  it 'should have a default message' do
-    ErrApp.error = {}
-    get '/'
-    last_response.body.should == 'Aww, hamburgers.'
-  end
-  
-  context 'with formatting' do
-    
-  end
-end

data/spec/grape/middleware/formatter_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-describe Grape::Middleware::Formatter do
-  subject{ Grape::Middleware::Formatter.new(app, :default_format => :json)}
-  before{ subject.stub!(:dup).and_return(subject) }
-  
-  let(:app){ lambda{|env| [200, {}, [@body]]} }
-  
-  context 'serialization' do
-    it 'should look at the bodies for possibly serializable data' do
-      @body = {"abc" => "def"}
-      status, headers, bodies = *subject.call({'PATH_INFO' => '/somewhere'})
-      bodies.each{|b| b.should == MultiJson.encode(@body) }
-    end
-    
-    it 'should call #to_json first if it is available' do
-      @body = "string"
-      @body.instance_eval do
-        def to_json
-          "\"bar\""
-        end
-      end
-      
-      subject.call({'PATH_INFO' => '/somewhere'}).last.each{|b| b.should == '"bar"'}
-    end
-    
-    it 'should serialize the #serializable_hash if that is available' do
-      class SimpleExample
-        def serializable_hash
-          {:abc => 'def'}
-        end
-      end
-      
-      @body = SimpleExample.new
-      
-      subject.call({'PATH_INFO' => '/somewhere'}).last.each{|b| b.should == '{"abc":"def"}'}
-    end
-  end
-  
-  context 'detection' do
-    it 'should use the extension if one is provided' do
-      subject.call({'PATH_INFO' => '/info.xml'})
-      subject.env['api.format'].should == :xml
-      subject.call({'PATH_INFO' => '/info.json'})
-      subject.env['api.format'].should == :json
-    end
-    
-    it 'should use the default format if none is provided' do
-      subject.call({'PATH_INFO' => '/info'})
-      subject.env['api.format'].should == :json
-    end
-    
-    it 'should throw an error on an unrecognized format' do
-      err = catch(:error){ subject.call({'PATH_INFO' => '/info.barklar'}) }
-      err.should == {:status => 406, :message => "The requested format is not supported."}
-    end
-  end
-  
-  context 'Accept header detection' do
-    it 'should detect from the Accept header' do
-      subject.call({'PATH_INFO' => '/info', 'Accept' => 'application/xml'})
-      subject.env['api.format'].should == :xml
-    end
-    
-    it 'should look for case-indifferent headers' do
-      subject.call({'PATH_INFO' => '/info', 'accept' => 'application/xml'})
-      subject.env['api.format'].should == :xml
-    end
-    
-    it 'should use quality rankings to determine formats' do
-      subject.call({'PATH_INFO' => '/info', 'Accept' => 'application/json; q=0.3,application/xml; q=1.0'})
-      subject.env['api.format'].should == :xml
-      subject.call({'PATH_INFO' => '/info', 'Accept' => 'application/json; q=1.0,application/xml; q=0.3'})
-      subject.env['api.format'].should == :json
-    end
-    
-    it 'should handle quality rankings mixed with nothing' do
-      subject.call({'PATH_INFO' => '/info', 'Accept' => 'application/json,application/xml; q=1.0'})
-      subject.env['api.format'].should == :xml
-    end
-    
-    it 'should properly parse headers with other attributes' do
-      subject.call({'PATH_INFO' => '/info', 'Accept' => 'application/json; abc=2.3; q=1.0,application/xml; q=0.7'})
-      subject.env['api.format'].should == :json
-    end
-  end
-end

data/spec/grape/middleware/prefixer_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe Grape::Middleware::Prefixer do
-  let(:app){ lambda{|env| [200, {}, env['PATH_INFO']]} }
-  subject{ Grape::Middleware::Prefixer.new(app, @options || {}) }
-
-  it 'should lop off a prefix (without a slash)' do
-    @options = {:prefix => 'monkey'}
-    subject.call('PATH_INFO' => '/monkey/beeswax').last.should == '/beeswax'
-  end
-  
-  it 'should lop off a prefix (with a slash)' do
-    @options = {:prefix => '/banana'}
-    subject.call('PATH_INFO' => '/banana/peel').last.should == '/peel'
-  end
-  
-  it 'should not lop off non-prefixes' do
-    @options = {:prefix => '/monkey'}
-    subject.call('PATH_INFO' => '/banana/peel').last.should == '/banana/peel'
-  end
-  
-  it 'should pass through unaltered if there is no prefix' do
-    subject.call('PATH_INFO' => '/awesome').last.should == '/awesome'
-  end
-  
-  it 'should only remove the first instance of the prefix' do
-    @options = {:prefix => 'api'}
-    subject.call('PATH_INFO' => '/api/v1/api/awesome').last.should == '/v1/api/awesome'
-  end
-end

data/spec/grape/middleware/versioner_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Grape::Middleware::Versioner do
-  let(:app) { lambda{|env| [200, env, env['api.version']]} }
-  subject { Grape::Middleware::Versioner.new(app, @options || {}) }
-  
-  it 'should set the API version based on the first path' do
-    subject.call('PATH_INFO' => '/v1/awesome').last.should == 'v1'
-  end
-  
-  it 'should cut the version out of the path' do
-    subject.call('PATH_INFO' => '/v1/awesome')[1]['PATH_INFO'].should == '/awesome'
-  end
-  
-  it 'should provide a nil version if no path is given' do
-    subject.call('PATH_INFO' => '/').last.should be_nil
-  end
-  
-  context 'with a pattern' do
-    before{ @options = {:pattern => /v./i} }
-    it 'should set the version if it matches' do
-      subject.call('PATH_INFO' => '/v1/awesome').last.should == 'v1'
-    end
-    
-    it 'should ignore the version if it fails to match' do
-      subject.call('PATH_INFO' => '/awesome/radical').last.should be_nil
-    end
-  end
-  
-  context 'with specified versions' do
-    before{ @options = {:versions => ['v1', 'v2']}}
-    it 'should throw an error if a non-allowed version is specified' do
-      catch(:error){subject.call('PATH_INFO' => '/v3/awesome')}[:status].should == 404
-    end
-    
-    it 'should allow versions that have been specified' do
-      subject.call('PATH_INFO' => '/v1/asoasd').last.should == 'v1'
-    end
-  end
-end

data/spec/grape/middleware_stack_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe Grape::MiddlewareStack do
-  subject { Grape::MiddlewareStack.new }
-  
-  it 'should be able to add middlewares' do
-    subject.use Grape::Middleware::Error
-    subject.stack.first.should == [Grape::Middleware::Error]
-  end
-  
-  context 'class uniqueness' do
-    it 'should not increase the stack size when doubling up on a use' do
-      2.times{ subject.use Grape::Middleware::Error }
-      subject.stack.size.should == 1
-    end
-    
-    it 'should increase the stack size when a novel class is added' do
-      subject.use Grape::Middleware::Error
-      subject.use Grape::Middleware::Prefixer
-      subject.use Grape::Middleware::Error
-      subject.stack.should == [[Grape::Middleware::Error], [Grape::Middleware::Prefixer]]
-    end
-  end
-  
-  describe '#run' do
-    class ExampleMiddleware
-      def initialize(app, say = 'what')
-        @app = app
-        @say = say
-      end
-
-      def call(env)
-        (env['say'] ||= []) << @say
-        @app.call(env)
-      end
-    end
-    
-    before do
-      subject.use ExampleMiddleware
-      subject.use ExampleMiddleware, 'yo'
-    end
-    
-    it 'should call the middlewares in the stack' do
-      subject.to_app(lambda{|env| env['say'].should == ['yo']}).call({})
-    end
-  end
-end

data/spec/grape_spec.rb

@@ -1 +0,0 @@
-require 'spec_helper'

data/spec/spec_helper.rb

@@ -1,20 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'grape'
-
-require 'rubygems'
-require 'bundler'
-Bundler.setup :default, :test
-
-require 'rspec'
-require 'rack/test'
-
-require 'base64'
-def encode_basic(username, password)
-  "Basic " + Base64.encode64("#{username}:#{password}")
-end
-
-RSpec.configure do |config|
-  config.include Rack::Test::Methods
-end