grape 0.7.0 → 0.8.0

data/spec/grape/validations/default_spec.rb

@@ -74,50 +74,50 @@ describe Grape::Validations::DefaultValidator do
 
   it 'set default value for optional param' do
     get("/")
-    last_response.status.should == 200
-    last_response.body.should == { id: nil, type: 'default-type' }.to_json
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq({ id: nil, type: 'default-type' }.to_json)
   end
 
   it 'set default values for optional params' do
     get("/user")
-    last_response.status.should == 200
-    last_response.body.should == { type1: 'default-type1', type2: 'default-type2' }.to_json
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq({ type1: 'default-type1', type2: 'default-type2' }.to_json)
   end
 
   it 'set default values for missing params in the request' do
     get("/user?type2=value2")
-    last_response.status.should == 200
-    last_response.body.should == { type1: 'default-type1', type2: 'value2' }.to_json
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq({ type1: 'default-type1', type2: 'value2' }.to_json)
   end
 
   it 'set default values for optional params and allow to use required fields in the same time' do
     get("/message?id=1")
-    last_response.status.should == 200
-    last_response.body.should == { id: '1', type1: 'default-type1', type2: 'default-type2' }.to_json
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq({ id: '1', type1: 'default-type1', type2: 'default-type2' }.to_json)
   end
 
   it 'sets lambda based defaults at the time of call' do
     get("/numbers")
-    last_response.status.should == 200
+    expect(last_response.status).to eq(200)
     before = JSON.parse(last_response.body)
     get("/numbers")
-    last_response.status.should == 200
+    expect(last_response.status).to eq(200)
     after = JSON.parse(last_response.body)
 
-    before['non_random_number'].should == after['non_random_number']
-    before['random_number'].should_not == after['random_number']
+    expect(before['non_random_number']).to eq(after['non_random_number'])
+    expect(before['random_number']).not_to eq(after['random_number'])
   end
 
   it 'set default values for optional grouped params' do
     get('/group')
-    last_response.status.should == 200
-    last_response.body.should == { foo_bar: 'foo-bar' }.to_json
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq({ foo_bar: 'foo-bar' }.to_json)
   end
 
   it 'sets default values for grouped arrays' do
     get('/array?array[][name]=name&array[][name]=name2&array[][with_default]=bar2')
-    last_response.status.should == 200
-    last_response.body.should == { array: [{ name: "name", with_default: "default" }, { name: "name2", with_default: "bar2" }] }.to_json
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq({ array: [{ name: "name", with_default: "default" }, { name: "name2", with_default: "bar2" }] }.to_json)
   end
 
 end

data/spec/grape/validations/exactly_one_of_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Grape::Validations::ExactlyOneOfValidator do
+  describe '#validate!' do
+    let(:scope) do
+      Struct.new(:opts) do
+        def params(arg); end
+      end
+    end
+    let(:exactly_one_of_params) { [:beer, :wine, :grapefruit] }
+    let(:validator) { described_class.new(exactly_one_of_params, {}, false, scope.new) }
+
+    context 'when all restricted params are present' do
+      let(:params) { { beer: true, wine: true, grapefruit: true } }
+
+      it 'raises a validation exception' do
+        expect {
+          validator.validate! params
+        }.to raise_error(Grape::Exceptions::Validation)
+      end
+
+      context 'mixed with other params' do
+        let(:mixed_params) { params.merge!(other: true, andanother: true) }
+
+        it 'still raises a validation exception' do
+          expect {
+            validator.validate! mixed_params
+          }.to raise_error(Grape::Exceptions::Validation)
+        end
+      end
+    end
+
+    context 'when a subset of restricted params are present' do
+      let(:params) { { beer: true, grapefruit: true } }
+
+      it 'raises a validation exception' do
+        expect {
+          validator.validate! params
+        }.to raise_error(Grape::Exceptions::Validation)
+      end
+    end
+
+    context 'when params keys come as strings' do
+      let(:params) { { 'beer' => true, 'grapefruit' => true } }
+
+      it 'raises a validation exception' do
+        expect {
+          validator.validate! params
+        }.to raise_error(Grape::Exceptions::Validation)
+      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 'params' do
+        expect(validator.validate!(params)).to eql params
+      end
+    end
+  end
+end

data/spec/grape/validations/mutual_exclusion_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Grape::Validations::MutualExclusionValidator do
+  describe '#validate!' do
+    let(:scope) do
+      Struct.new(:opts) do
+        def params(arg); end
+      end
+    end
+    let(:mutually_exclusive_params) { [:beer, :wine, :grapefruit] }
+    let(:validator) { described_class.new(mutually_exclusive_params, {}, false, scope.new) }
+
+    context 'when all mutually exclusive params are present' do
+      let(:params) { { beer: true, wine: true, grapefruit: true } }
+
+      it 'raises a validation exception' do
+        expect {
+          validator.validate! params
+        }.to raise_error(Grape::Exceptions::Validation)
+      end
+
+      context 'mixed with other params' do
+        let(:mixed_params) { params.merge!(other: true, andanother: true) }
+
+        it 'still raises a validation exception' do
+          expect {
+            validator.validate! mixed_params
+          }.to raise_error(Grape::Exceptions::Validation)
+        end
+      end
+    end
+
+    context 'when a subset of mutually exclusive params are present' do
+      let(:params) { { beer: true, grapefruit: true } }
+
+      it 'raises a validation exception' do
+        expect {
+          validator.validate! params
+        }.to raise_error(Grape::Exceptions::Validation)
+      end
+    end
+
+    context 'when params keys come as strings' do
+      let(:params) { { 'beer' => true, 'grapefruit' => true } }
+
+      it 'raises a validation exception' do
+        expect {
+          validator.validate! params
+        }.to raise_error(Grape::Exceptions::Validation)
+      end
+    end
+
+    context 'when no mutually exclusive params are present' do
+      let(:params) { { beer: true, somethingelse: true } }
+
+      it 'params' do
+        expect(validator.validate!(params)).to eql params
+      end
+    end
+  end
+end

data/spec/grape/validations/presence_spec.rb

@@ -61,82 +61,82 @@ describe Grape::Validations::PresenceValidator do
 
   it 'does not validate for any params' do
     get "/bacons"
-    last_response.status.should == 200
-    last_response.body.should == "All the bacon".to_json
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq("All the bacon".to_json)
   end
 
   it 'validates id' do
     post '/'
-    last_response.status.should == 400
-    last_response.body.should == '{"error":"id is missing"}'
+    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
-    last_response.body.should == '{"error":"id is invalid"}'
-    last_response.status.should == 400
+    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
-    last_response.body.should == '{"ret":56}'
-    last_response.status.should == 201
+    expect(last_response.body).to eq('{"ret":56}')
+    expect(last_response.status).to eq(201)
   end
 
   it 'validates name, company' do
     get '/'
-    last_response.status.should == 400
-    last_response.body.should == '{"error":"name is missing"}'
+    expect(last_response.status).to eq(400)
+    expect(last_response.body).to eq('{"error":"name is missing"}')
 
     get '/', name: "Bob"
-    last_response.status.should == 400
-    last_response.body.should == '{"error":"company is missing"}'
+    expect(last_response.status).to eq(400)
+    expect(last_response.body).to eq('{"error":"company is missing"}')
 
     get '/', name: "Bob", company: "TestCorp"
-    last_response.status.should == 200
-    last_response.body.should == "Hello".to_json
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq("Hello".to_json)
   end
 
   it 'validates nested parameters' do
     get '/nested'
-    last_response.status.should == 400
-    last_response.body.should == '{"error":"user is missing, user[first_name] is missing, user[last_name] is missing"}'
+    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" }
-    last_response.status.should == 400
-    last_response.body.should == '{"error":"user[last_name] is missing"}'
+    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" }
-    last_response.status.should == 200
-    last_response.body.should == "Nested".to_json
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq("Nested".to_json)
   end
 
   it 'validates triple nested parameters' do
     get '/nested_triple'
-    last_response.status.should == 400
-    last_response.body.should include '{"error":"admin is missing'
+    expect(last_response.status).to eq(400)
+    expect(last_response.body).to include '{"error":"admin is missing'
 
     get '/nested_triple', user: { first_name: "Billy" }
-    last_response.status.should == 400
-    last_response.body.should include '{"error":"admin is missing'
+    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" } }
-    last_response.status.should == 400
-    last_response.body.should == '{"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"}'
+    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" } }
-    last_response.status.should == 400
-    last_response.body.should include '{"error":"admin is missing'
+    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" } } }
-    last_response.status.should == 400
-    last_response.body.should == '{"error":"admin[admin_name] is missing, admin[super][user][last_name] is missing"}'
+    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" } } }
-    last_response.status.should == 400
-    last_response.body.should == '{"error":"admin[super][user][last_name] is missing"}'
+    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" } } }
-    last_response.status.should == 200
-    last_response.body.should == "Nested triple".to_json
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq("Nested triple".to_json)
   end
 
 end

data/spec/grape/validations/regexp_spec.rb

@@ -20,14 +20,21 @@ describe Grape::Validations::RegexpValidator do
     ValidationsSpec::RegexpValidatorSpec::API
   end
 
-  it 'refuses invalid input' do
-    get '/', name: "invalid name"
-    last_response.status.should == 400
+  context 'invalid input' do
+    it 'refuses inapppopriate' do
+      get '/', name: "invalid name"
+      expect(last_response.status).to eq(400)
+    end
+
+    it 'refuses nil' do
+      get '/', name: nil
+      expect(last_response.status).to eq(400)
+    end
   end
 
   it 'accepts valid input' do
     get '/', name: "bob"
-    last_response.status.should == 200
+    expect(last_response.status).to eq(200)
   end
 
 end

data/spec/grape/validations/values_spec.rb

@@ -49,6 +49,13 @@ describe Grape::Validations::ValuesValidator do
         get '/values/coercion' do
           { type: params[:type] }
         end
+
+        params do
+          optional :optional do
+            requires :type, values: ["a", "b"]
+          end
+        end
+        get '/optional_with_required_values'
       end
     end
   end
@@ -59,54 +66,61 @@ describe Grape::Validations::ValuesValidator do
 
   it 'allows a valid value for a parameter' do
     get("/", type: 'valid-type1')
-    last_response.status.should eq 200
-    last_response.body.should eq({ type: "valid-type1" }.to_json)
+    expect(last_response.status).to eq 200
+    expect(last_response.body).to eq({ type: "valid-type1" }.to_json)
   end
 
   it 'does not allow an invalid value for a parameter' do
     get("/", type: 'invalid-type')
-    last_response.status.should eq 400
-    last_response.body.should eq({ error: "type does not have a valid value" }.to_json)
+    expect(last_response.status).to eq 400
+    expect(last_response.body).to eq({ error: "type does not have a valid value" }.to_json)
   end
 
-  it 'does not allow nil value for a parameter' do
-    get("/", type: nil)
-    last_response.status.should eq 400
-    last_response.body.should eq({ error: "type does not have a valid value" }.to_json)
+  context 'nil value for a parameter' do
+    it 'does not allow for root params scope' do
+      get("/", type: nil)
+      expect(last_response.status).to eq 400
+      expect(last_response.body).to eq({ error: "type does not have a valid value" }.to_json)
+    end
+
+    it 'allows for a required param in child scope' do
+      get('/optional_with_required_values')
+      expect(last_response.status).to eq 200
+    end
   end
 
   it 'allows a valid default value' do
     get("/default/valid")
-    last_response.status.should eq 200
-    last_response.body.should eq({ type: "valid-type2" }.to_json)
+    expect(last_response.status).to eq 200
+    expect(last_response.body).to eq({ type: "valid-type2" }.to_json)
   end
 
   it 'allows a proc for values' do
     get('/lambda', type: 'valid-type1')
-    last_response.status.should eq 200
-    last_response.body.should eq({ type: "valid-type1" }.to_json)
+    expect(last_response.status).to eq 200
+    expect(last_response.body).to eq({ type: "valid-type1" }.to_json)
   end
 
   it 'does not validate updated values without proc' do
     ValuesModel.add_value('valid-type4')
 
     get('/', type: 'valid-type4')
-    last_response.status.should eq 400
-    last_response.body.should eq({ error: "type does not have a valid value" }.to_json)
+    expect(last_response.status).to eq 400
+    expect(last_response.body).to eq({ error: "type does not have a valid value" }.to_json)
   end
 
   it 'validates against values in a proc' do
     ValuesModel.add_value('valid-type4')
 
     get('/lambda', type: 'valid-type4')
-    last_response.status.should eq 200
-    last_response.body.should eq({ type: "valid-type4" }.to_json)
+    expect(last_response.status).to eq 200
+    expect(last_response.body).to eq({ type: "valid-type4" }.to_json)
   end
 
   it 'does not allow an invalid value for a parameter using lambda' do
     get("/lambda", type: 'invalid-type')
-    last_response.status.should eq 400
-    last_response.body.should eq({ error: "type does not have a valid value" }.to_json)
+    expect(last_response.status).to eq 400
+    expect(last_response.body).to eq({ error: "type does not have a valid value" }.to_json)
   end
 
   it 'raises IncompatibleOptionValues on an invalid default value' do
@@ -125,8 +139,8 @@ describe Grape::Validations::ValuesValidator do
 
   it 'allows values to be a kind of the coerced type not just an instance of it' do
     get("/values/coercion", type: 10)
-    last_response.status.should eq 200
-    last_response.body.should eq({ type: 10 }.to_json)
+    expect(last_response.status).to eq 200
+    expect(last_response.body).to eq({ type: 10 }.to_json)
   end
 
   it 'raises IncompatibleOptionValues when values contains a value that is not a kind of the type' do