grape 0.8.0 → 0.9.0

data/spec/grape/middleware/exception_spec.rb

@@ -54,6 +54,7 @@ describe Grape::Middleware::Error do
 
   it 'does not trap errors by default' do
     @app ||= Rack::Builder.app do
+      use Spec::Support::EndpointFaker
       use Grape::Middleware::Error
       run ExceptionApp
     end
@@ -63,6 +64,7 @@ describe Grape::Middleware::Error do
   context 'with rescue_all set to true' do
     it 'sets the message appropriately' do
       @app ||= Rack::Builder.app do
+        use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true
         run ExceptionApp
       end
@@ -72,6 +74,7 @@ describe Grape::Middleware::Error do
 
     it 'defaults to a 500 status' do
       @app ||= Rack::Builder.app do
+        use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true
         run ExceptionApp
       end
@@ -81,6 +84,7 @@ describe Grape::Middleware::Error do
 
     it 'is possible to specify a different default status code' do
       @app ||= Rack::Builder.app do
+        use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true, default_status: 500
         run ExceptionApp
       end
@@ -90,6 +94,7 @@ describe Grape::Middleware::Error do
 
     it 'is possible to return errors in json format' do
       @app ||= Rack::Builder.app do
+        use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true, format: :json
         run ExceptionApp
       end
@@ -99,6 +104,7 @@ describe Grape::Middleware::Error do
 
     it 'is possible to return hash errors in json format' do
       @app ||= Rack::Builder.app do
+        use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true, format: :json
         run ErrorHashApp
       end
@@ -109,6 +115,7 @@ describe Grape::Middleware::Error do
 
     it 'is possible to return errors in jsonapi format' do
       @app ||= Rack::Builder.app do
+        use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true, format: :jsonapi
         run ExceptionApp
       end
@@ -118,6 +125,7 @@ describe Grape::Middleware::Error do
 
     it 'is possible to return hash errors in jsonapi format' do
       @app ||= Rack::Builder.app do
+        use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true, format: :jsonapi
         run ErrorHashApp
       end
@@ -128,6 +136,7 @@ describe Grape::Middleware::Error do
 
     it 'is possible to return errors in xml format' do
       @app ||= Rack::Builder.app do
+        use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true, format: :xml
         run ExceptionApp
       end
@@ -137,6 +146,7 @@ describe Grape::Middleware::Error do
 
     it 'is possible to return hash errors in xml format' do
       @app ||= Rack::Builder.app do
+        use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true, format: :xml
         run ErrorHashApp
       end
@@ -147,6 +157,7 @@ describe Grape::Middleware::Error do
 
     it 'is possible to specify a custom formatter' do
       @app ||= Rack::Builder.app do
+        use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true,
                                       format: :custom,
                                       error_formatters: {
@@ -162,6 +173,7 @@ describe Grape::Middleware::Error do
 
     it 'does not trap regular error! codes' do
       @app ||= Rack::Builder.app do
+        use Spec::Support::EndpointFaker
         use Grape::Middleware::Error
         run AccessDeniedApp
       end
@@ -171,6 +183,7 @@ describe Grape::Middleware::Error do
 
     it 'responds to custom Grape exceptions appropriately' do
       @app ||= Rack::Builder.app do
+        use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: false
         run CustomErrorApp
       end

data/spec/grape/validations/at_least_one_of_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Grape::Validations::AtLeastOneOfValidator do
+  describe '#validate!' do
+    let(:scope) do
+      Struct.new(:opts) do
+        def params(arg); end
+      end
+    end
+    let(:at_least_one_of_params) { [:beer, :wine, :grapefruit] }
+    let(:validator) { described_class.new(at_least_one_of_params, {}, false, scope.new) }
+
+    context 'when all restricted params are present' do
+      let(:params) { { beer: true, wine: true, grapefruit: true } }
+
+      it 'does not raise a validation exception' do
+        expect(validator.validate!(params)).to eql params
+      end
+
+      context 'mixed with other params' do
+        let(:mixed_params) { params.merge!(other: true, andanother: true) }
+
+        it 'does not raise a validation exception' do
+          expect(validator.validate!(mixed_params)).to eql mixed_params
+        end
+      end
+    end
+
+    context 'when a subset of restricted params are present' do
+      let(:params) { { beer: true, grapefruit: true } }
+
+      it 'does not raise a validation exception' do
+        expect(validator.validate!(params)).to eql params
+      end
+    end
+
+    context 'when params keys come as strings' do
+      let(:params) { { 'beer' => true, 'grapefruit' => true } }
+
+      it 'does not raise a validation exception' do
+        expect(validator.validate!(params)).to eql params
+      end
+    end
+
+    context 'when none of the restricted params is selected' do
+      let(:params) { { somethingelse: true } }
+
+      it 'raises a validation exception' do
+        expect {
+          validator.validate! params
+        }.to raise_error(Grape::Exceptions::Validation)
+      end
+    end
+
+    context 'when exactly one of the restricted params is selected' do
+      let(:params) { { beer: true, somethingelse: true } }
+
+      it 'does not raise a validation exception' do
+        expect(validator.validate!(params)).to eql params
+      end
+    end
+  end
+end

data/spec/grape/validations/exactly_one_of_spec.rb

@@ -63,7 +63,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
     context 'when exactly one of the restricted params is selected' do
       let(:params) { { beer: true, somethingelse: true } }
 
-      it 'params' do
+      it 'does not raise a validation exception' do
         expect(validator.validate!(params)).to eql params
       end
     end

data/spec/grape/validations/presence_spec.rb

@@ -1,142 +1,179 @@
 require 'spec_helper'
 
 describe Grape::Validations::PresenceValidator do
+  subject do
+    Class.new(Grape::API) do
+      format :json
+    end
+  end
+  def app
+    subject
+  end
 
-  module ValidationsSpec
-    module PresenceValidatorSpec
-      class API < Grape::API
-        default_format :json
-
-        resource :bacons do
-          get do
-            "All the bacon"
-          end
-        end
-
-        params do
-          requires :id, regexp: /^[0-9]+$/
-        end
-        post do
-          { ret: params[:id] }
-        end
-
-        params do
-          requires :name, :company
-        end
+  context "without validation" do
+    before do
+      subject.resource :bacons do
         get do
-          "Hello"
-        end
-
-        params do
-          requires :user, type: Hash do
-            requires :first_name
-            requires :last_name
-          end
-        end
-        get '/nested' do
-          "Nested"
-        end
-
-        params do
-          requires :admin, type: Hash do
-            requires :admin_name
-            requires :super, type: Hash do
-              requires :user, type: Hash do
-                requires :first_name
-                requires :last_name
-              end
-            end
-          end
-        end
-        get '/nested_triple' do
-          "Nested triple"
+          "All the bacon"
         end
       end
     end
+    it 'does not validate for any params' do
+      get "/bacons"
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq("All the bacon".to_json)
+    end
   end
 
-  def app
-    ValidationsSpec::PresenceValidatorSpec::API
-  end
-
-  it 'does not validate for any params' do
-    get "/bacons"
-    expect(last_response.status).to eq(200)
-    expect(last_response.body).to eq("All the bacon".to_json)
+  context "with a required regexp parameter supplied in the POST body" do
+    before do
+      subject.format :json
+      subject.params do
+        requires :id, regexp: /^[0-9]+$/
+      end
+      subject.post do
+        { ret: params[:id] }
+      end
+    end
+    it 'validates id' do
+      post '/'
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('{"error":"id is missing"}')
+
+      io = StringIO.new('{"id" : "a56b"}')
+      post '/', {}, 'rack.input' => io, 'CONTENT_TYPE' => 'application/json', 'CONTENT_LENGTH' => io.length
+      expect(last_response.body).to eq('{"error":"id is invalid"}')
+      expect(last_response.status).to eq(400)
+
+      io = StringIO.new('{"id" : 56}')
+      post '/', {}, 'rack.input' => io, 'CONTENT_TYPE' => 'application/json', 'CONTENT_LENGTH' => io.length
+      expect(last_response.body).to eq('{"ret":56}')
+      expect(last_response.status).to eq(201)
+    end
   end
 
-  it 'validates id' do
-    post '/'
-    expect(last_response.status).to eq(400)
-    expect(last_response.body).to eq('{"error":"id is missing"}')
-
-    io = StringIO.new('{"id" : "a56b"}')
-    post '/', {}, 'rack.input' => io, 'CONTENT_TYPE' => 'application/json', 'CONTENT_LENGTH' => io.length
-    expect(last_response.body).to eq('{"error":"id is invalid"}')
-    expect(last_response.status).to eq(400)
-
-    io = StringIO.new('{"id" : 56}')
-    post '/', {}, 'rack.input' => io, 'CONTENT_TYPE' => 'application/json', 'CONTENT_LENGTH' => io.length
-    expect(last_response.body).to eq('{"ret":56}')
-    expect(last_response.status).to eq(201)
+  context "with a required non-empty string" do
+    before do
+      subject.params do
+        requires :email, type: String, regexp: /^\S+$/
+      end
+      subject.get do
+        "Hello"
+      end
+    end
+    it 'requires when missing' do
+      get '/'
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('{"error":"email is missing, email is invalid"}')
+    end
+    it 'requires when empty' do
+      get '/', email: ""
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('{"error":"email is invalid"}')
+    end
+    it "valid when set" do
+      get '/', email: "bob@example.com"
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq("Hello".to_json)
+    end
   end
 
-  it 'validates name, company' do
-    get '/'
-    expect(last_response.status).to eq(400)
-    expect(last_response.body).to eq('{"error":"name is missing"}')
-
-    get '/', name: "Bob"
-    expect(last_response.status).to eq(400)
-    expect(last_response.body).to eq('{"error":"company is missing"}')
-
-    get '/', name: "Bob", company: "TestCorp"
-    expect(last_response.status).to eq(200)
-    expect(last_response.body).to eq("Hello".to_json)
+  context "with required parameters and no type" do
+    before do
+      subject.params do
+        requires :name, :company
+      end
+      subject.get do
+        "Hello"
+      end
+    end
+    it 'validates name, company' do
+      get '/'
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('{"error":"name is missing"}')
+
+      get '/', name: "Bob"
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('{"error":"company is missing"}')
+
+      get '/', name: "Bob", company: "TestCorp"
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq("Hello".to_json)
+    end
   end
 
-  it 'validates nested parameters' do
-    get '/nested'
-    expect(last_response.status).to eq(400)
-    expect(last_response.body).to eq('{"error":"user is missing, user[first_name] is missing, user[last_name] is missing"}')
-
-    get '/nested', user: { first_name: "Billy" }
-    expect(last_response.status).to eq(400)
-    expect(last_response.body).to eq('{"error":"user[last_name] is missing"}')
-
-    get '/nested', user: { first_name: "Billy", last_name: "Bob" }
-    expect(last_response.status).to eq(200)
-    expect(last_response.body).to eq("Nested".to_json)
+  context "with nested parameters" do
+    before do
+      subject.params do
+        requires :user, type: Hash do
+          requires :first_name
+          requires :last_name
+        end
+      end
+      subject.get '/nested' do
+        "Nested"
+      end
+    end
+    it 'validates nested parameters' do
+      get '/nested'
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('{"error":"user is missing, user[first_name] is missing, user[last_name] is missing"}')
+
+      get '/nested', user: { first_name: "Billy" }
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('{"error":"user[last_name] is missing"}')
+
+      get '/nested', user: { first_name: "Billy", last_name: "Bob" }
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq("Nested".to_json)
+    end
   end
 
-  it 'validates triple nested parameters' do
-    get '/nested_triple'
-    expect(last_response.status).to eq(400)
-    expect(last_response.body).to include '{"error":"admin is missing'
-
-    get '/nested_triple', user: { first_name: "Billy" }
-    expect(last_response.status).to eq(400)
-    expect(last_response.body).to include '{"error":"admin is missing'
-
-    get '/nested_triple', admin: { super: { first_name: "Billy" } }
-    expect(last_response.status).to eq(400)
-    expect(last_response.body).to eq('{"error":"admin[admin_name] is missing, admin[super][user] is missing, admin[super][user][first_name] is missing, admin[super][user][last_name] is missing"}')
-
-    get '/nested_triple', super: { user: { first_name: "Billy", last_name: "Bob" } }
-    expect(last_response.status).to eq(400)
-    expect(last_response.body).to include '{"error":"admin is missing'
-
-    get '/nested_triple', admin: { super: { user: { first_name: "Billy" } } }
-    expect(last_response.status).to eq(400)
-    expect(last_response.body).to eq('{"error":"admin[admin_name] is missing, admin[super][user][last_name] is missing"}')
-
-    get '/nested_triple', admin: { admin_name: 'admin', super: { user: { first_name: "Billy" } } }
-    expect(last_response.status).to eq(400)
-    expect(last_response.body).to eq('{"error":"admin[super][user][last_name] is missing"}')
-
-    get '/nested_triple', admin: { admin_name: 'admin', super: { user: { first_name: "Billy", last_name: "Bob" } } }
-    expect(last_response.status).to eq(200)
-    expect(last_response.body).to eq("Nested triple".to_json)
+  context "with triply nested required parameters" do
+    before do
+      subject.params do
+        requires :admin, type: Hash do
+          requires :admin_name
+          requires :super, type: Hash do
+            requires :user, type: Hash do
+              requires :first_name
+              requires :last_name
+            end
+          end
+        end
+      end
+      subject.get '/nested_triple' do
+        "Nested triple"
+      end
+    end
+    it 'validates triple nested parameters' do
+      get '/nested_triple'
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to include '{"error":"admin is missing'
+
+      get '/nested_triple', user: { first_name: "Billy" }
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to include '{"error":"admin is missing'
+
+      get '/nested_triple', admin: { super: { first_name: "Billy" } }
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('{"error":"admin[admin_name] is missing, admin[super][user] is missing, admin[super][user][first_name] is missing, admin[super][user][last_name] is missing"}')
+
+      get '/nested_triple', super: { user: { first_name: "Billy", last_name: "Bob" } }
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to include '{"error":"admin is missing'
+
+      get '/nested_triple', admin: { super: { user: { first_name: "Billy" } } }
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('{"error":"admin[admin_name] is missing, admin[super][user][last_name] is missing"}')
+
+      get '/nested_triple', admin: { admin_name: 'admin', super: { user: { first_name: "Billy" } } }
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('{"error":"admin[super][user][last_name] is missing"}')
+
+      get '/nested_triple', admin: { admin_name: 'admin', super: { user: { first_name: "Billy", last_name: "Bob" } } }
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq("Nested triple".to_json)
+    end
   end
-
 end