sinatra-param2 1.0.0

data/spec/parameter_conjunctivity_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe 'Parameter Sets' do
+  describe 'all_or_none_of' do
+    it 'returns 400 on requests that have some but not all required parameters' do
+      params = [
+        {a: 1},
+        {b: 2, c: 3},
+        {a: 1, c: 3},
+      ]
+
+      params.each do |param|
+        get('/all_or_none_of', param) do |response|
+          expect(response.status).to eql 400
+          expect(JSON.parse(response.body)['message']).to match(/^Invalid parameters/)
+        end
+      end
+    end
+
+    it 'returns successfully for requests that have all parameters' do
+      param = {a: 1, b: 2, c: 3}
+
+      response = get("/all_or_none_of", param)
+      expect(response.status).to eql 200
+      expect(JSON.parse(response.body)['message']).to match(/OK/)
+    end
+
+    it 'returns successfully for requests that have none of the parameters' do
+      response = get("/all_or_none_of")
+      expect(response.status).to eql 200
+      expect(JSON.parse(response.body)['message']).to match(/OK/)
+    end
+  end
+end

data/spec/parameter_exclusivity_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe 'Parameter Sets' do
+  describe 'one_of' do
+    it 'returns 400 on requests that contain more than one mutually exclusive parameter' do
+      params = [
+        {a: 1, b: 2},
+        {b: 2, c: 3},
+        {a: 1, b: 2, c: 3}
+      ]
+
+      params.each do |param|
+        get('/one_of/3', param) do |response|
+          expect(response.status).to eql 400
+          expect(JSON.parse(response.body)['message']).to match(/^Invalid parameters/)
+        end
+      end
+    end
+
+    it 'returns 400 on requests that contain more than one mutually exclusive parameter' do
+      params = {a: 1, b: 2}
+
+      get('/one_of/2', params) do |response|
+        expect(response.status).to eql 400
+        expect(JSON.parse(response.body)['message']).to match(/^Invalid parameters/)
+      end
+    end
+
+    it 'returns successfully for requests that have one parameter' do
+      params = [
+        {a: 1},
+        {b: 2},
+        {c: 3}
+      ]
+
+      (1..3).each do |n|
+        params.each do |param|
+          get("/one_of/#{n}", param) do |response|
+            expect(response.status).to eql 200
+            expect(JSON.parse(response.body)['message']).to match(/OK/)
+          end
+        end
+      end
+    end
+
+    it 'returns successfully for requests that have no parameter' do
+      (1..3).each do |n|
+        get("/one_of/#{n}") do |response|
+          expect(response.status).to eql 200
+          expect(JSON.parse(response.body)['message']).to match(/OK/)
+        end
+      end
+    end
+  end
+end

data/spec/parameter_inclusivity_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe 'Parameter Sets' do
+  describe 'any_of' do
+    it 'returns 400 on requests that contain fewer than one required parameter' do
+      get('/any_of', {}) do |response|
+        expect(response.status).to eql 400
+        expect(JSON.parse(response.body)['message']).to match(/Invalid parameters/)
+      end
+    end
+
+    it 'returns successfully for requests that have at least one parameter' do
+      params = [
+        {a: 1},
+        {b: 2},
+        {c: 3},
+        {a: 1, b: 2},
+        {b: 2, c: 3},
+        {a: 1, b: 2, c: 3}
+      ]
+
+      params.each do |param|
+        get("/any_of", param) do |response|
+          expect(response.status).to eql 200
+          expect(JSON.parse(response.body)['message']).to match(/OK/)
+        end
+      end
+    end
+  end
+end

data/spec/parameter_nested_validations_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+describe 'Nested Validation' do
+  context '' do
+    it 'should validate the children when the parent is present' do
+      params = {
+        :parent => {
+          :required_child => 1,
+        }
+      }
+
+      get("/validation/hash/nested_values", params) do |response|
+        expect(response.status).to eq(200)
+        expect(JSON.parse(response.body)['message']).to eq("OK")
+      end
+    end
+
+    it 'should be invalid when the parent is present but a nested validation fails' do
+      params = {
+        :parent => {
+          :optional_chlid => 'test'
+        }
+      }
+
+      get("/validation/hash/nested_values", params) do |response|
+        expect(response.status).to eq(400)
+        body = JSON.parse(response.body)
+        expect(body['message']).to eq("Parameter is required")
+        expect(body['errors']).to eq({
+          "parent[required_child]" => "Parameter is required"
+        })
+      end
+    end
+
+    it 'should not require sub params when the parent hash is not present and not required' do
+      params = {}
+      get("/validation/hash/nested_values", params) do |response|
+        expect(response.status).to eq(200)
+        expect(JSON.parse(response.body)['message']).to eq("OK")
+      end
+    end
+
+    it 'should allow arbitrary levels of nesting' do
+      params = {
+        :parent => {
+          :required_child => 1,
+          :nested_child => {
+            :required_sub_child => 'test'
+          }
+        }
+      }
+
+      get("/validation/hash/nested_values", params) do |response|
+        expect(response.status).to eq(200)
+        expect(JSON.parse(response.body)['message']).to eq("OK")
+      end
+    end
+
+    it 'should have the proper error message for multiple levels deep validation errors' do
+      params = {
+        :parent => {
+          :required_child => 1,
+          :nested_child => {
+            :required_sub_child => 'test',
+            :optional_sub_child => 'test'
+          }
+        }
+      }
+
+      get("/validation/hash/nested_values", params) do |response|
+        expect(response.status).to eq(400)
+        body = JSON.parse(response.body)
+        expect(body['message']).to eq("'test' is not a valid Integer")
+        expect(body['errors']).to eq({
+          "parent[nested_child][optional_sub_child]" => "'test' is not a valid Integer"
+        })
+      end
+    end
+
+    it 'should error when sub hash validation is tried on a non Hash parameter' do
+      params = {
+        :parent => {
+          :child => 'test'
+        }
+      }
+
+      get("/validation/hash/bad_nested_values", params) do |response|
+        expect(response.status).to eq(400)
+        body = JSON.parse(response.body)
+        expect(body['message']).to eq("Only the Hash parameter validation can use sub hash validation method")
+        expect(body['errors']).to eq({
+          "parent" => "Only the Hash parameter validation can use sub hash validation method"
+        })
+      end
+    end
+
+    it 'should work with one_of nested in a hash' do
+      params = {
+        :parent => {
+          :a => 'test'
+        }
+      }
+
+      get("/one_of/nested", params) do |response|
+        expect(response.status).to eq(200)
+        expect(JSON.parse(response.body)['message']).to eq("OK")
+      end
+    end
+
+    it "should error when one_of isn't satisfied in a nested hash" do
+      params = {
+        :parent => {
+          :a => 'test',
+          :b => 'test'
+        }
+      }
+
+      get("/one_of/nested", params) do |response|
+        expect(response.status).to eq(400)
+        expect(JSON.parse(response.body)['message']).to eq("Invalid parameters parent[[a, b, c]]")
+      end
+    end
+
+    it 'should work with any_of nested in a hash' do
+      params = {
+        :parent => {
+          :a => 'test'
+        }
+      }
+
+      get("/any_of/nested", params) do |response|
+        expect(response.status).to eq(200)
+        expect(JSON.parse(response.body)['message']).to eq("OK")
+      end
+    end
+
+    it "should error when one_of isn't satisfied in a nested hash" do
+      params = {
+        :parent => {
+          :d => 'test'
+        }
+      }
+
+      get("/any_of/nested", params) do |response|
+        expect(response.status).to eq(400)
+        expect(JSON.parse(response.body)['message']).to eq("Invalid parameters parent[[a, b, c]]")
+      end
+    end
+
+  end
+end

data/spec/parameter_raise_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe 'Exception' do
+  describe 'raise' do
+    it 'should raise error when option is specified' do
+      expect {
+        get('/raise/validation/required')
+      }.to raise_error(Sinatra::Param::InvalidParameterError)
+    end
+  end
+
+  it 'should raise error when more than one parameter is specified' do
+    params = {a: 1, b: 2, c: 3}
+    expect {
+      get('/raise/one_of/3', params)
+    }.to raise_error(Sinatra::Param::InvalidParameterError)
+  end
+
+  it 'should raise error when no parameters are specified' do
+    params = {}
+    expect {
+      get('/raise/any_of', params)
+    }.to raise_error(Sinatra::Param::InvalidParameterError)
+  end
+end

data/spec/parameter_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe 'Parameter' do
+  it 'only sets parameters present in request or with a default value' do
+    get('/', a: 'a', b: 'b') do |response|
+      response_body = JSON.parse(response.body)
+      expect(response_body).to be_member('a')
+      expect(response_body).to be_member('b')
+      expect(response_body).to be_member('c')
+      expect(response_body).to_not be_member('d')
+    end
+  end
+
+  it 'stringifies parameters' do
+    get('/keys/stringify', q: 'test') do |response|
+      expect(response.body).to eq 'TEST'
+    end
+  end
+end

data/spec/parameter_transformations_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'Parameter Transformations' do
+  describe 'default' do
+    it 'sets a default value when none is given' do
+      get('/default') do |response|
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['sort']).to eql 'title'
+      end
+    end
+
+    it 'sets a default value from an empty hash' do
+      get('/default/hash') do |response|
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['attributes']).to eql Hash.new
+      end
+    end
+
+    it 'sets a default value from a proc' do
+      get('/default/proc') do |response|
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['year']).to eql 2014
+      end
+    end
+  end
+
+  describe 'transform' do
+    it 'transforms the input using to_proc' do
+      get('/transform', order: 'asc') do |response|
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['order']).to eql 'ASC'
+      end
+    end
+
+    it 'skips transformations when the value is nil' do
+      get('/transform/required') do |response|
+        expect(response.status).to eql 400
+        expect(JSON.parse(response.body)['message']).to eq("Parameter is required")
+      end
+    end
+  end
+end

data/spec/parameter_type_coercion_spec.rb

@@ -0,0 +1,211 @@
+require 'spec_helper'
+
+describe 'Parameter Types' do
+  describe 'String' do
+    it 'coerces strings' do
+      get('/coerce/string', arg: '1234') do |response|
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['arg']).to eq('1234')
+      end
+    end
+  end
+
+  describe 'Integer' do
+    it 'coerces integers' do
+      get('/coerce/integer', arg: '1234') do |response|
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['arg']).to eq(1234)
+      end
+    end
+
+    it 'returns 400 on requests when integer is invalid' do
+      get('/coerce/integer', arg: '123abc') do |response|
+        expect(response.status).to eql 400
+        expect(JSON.parse(response.body)['message']).to eq("'123abc' is not a valid Integer")
+      end
+    end
+  end
+
+  describe 'Float' do
+    it 'coerces floats' do
+      get('/coerce/float', arg: '1234') do |response|
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['arg']).to eq(1234.0)
+      end
+    end
+
+    it 'returns 400 on requests when float is invalid' do
+      get('/coerce/float', arg: '123abc') do |response|
+        expect(response.status).to eql 400
+        expect(JSON.parse(response.body)['message']).to eq("'123abc' is not a valid Float")
+      end
+    end
+  end
+
+  describe 'Time' do
+    it 'coerces time' do
+      get('/coerce/time', arg: '20130117') do |response|
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['arg']).to match(/2013-01-17 00:00:00/)
+      end
+    end
+
+    it 'returns 400 on requests when time is invalid' do
+      get('/coerce/time', arg: '123abc') do |response|
+        expect(response.status).to eql 400
+        expect(JSON.parse(response.body)['message']).to eq("'123abc' is not a valid Time")
+      end
+    end
+  end
+
+  describe 'Date' do
+    it 'coerces date' do
+      get('/coerce/date', arg: '20130117') do |response|
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['arg']).to eq('2013-01-17')
+      end
+    end
+
+    it 'returns 400 on requests when date is invalid' do
+      get('/coerce/date', arg: 'abc') do |response|
+        expect(response.status).to eql 400
+        expect(JSON.parse(response.body)['message']).to eq("'abc' is not a valid Date")
+      end
+    end
+  end
+
+  describe 'DateTime' do
+    it 'coerces datetimes' do
+      get('/coerce/datetime', arg: '20130117') do |response|
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['arg']).to eq('2013-01-17T00:00:00+00:00')
+      end
+    end
+
+    it 'returns 400 on requests when datetime is invalid' do
+      get('/coerce/datetime', arg: 'abc') do |response|
+        expect(response.status).to eql 400
+        expect(JSON.parse(response.body)['message']).to eq("'abc' is not a valid DateTime")
+      end
+    end
+  end
+
+  describe 'Array' do
+    it 'coerces arrays' do
+      get('/coerce/array', arg: '1,2,3,4,5') do |response|
+        expect(response.status).to eql 200
+        parsed_body = JSON.parse(response.body)
+        expect(parsed_body['arg']).to be_an(Array)
+        expect(parsed_body['arg']).to eq(%w(1 2 3 4 5))
+      end
+    end
+
+    it 'coerces arrays of size 1' do
+      get('/coerce/array', arg: '1') do |response|
+        expect(response.status).to eql 200
+        parsed_body = JSON.parse(response.body)
+        expect(parsed_body['arg']).to be_an(Array)
+        expect(parsed_body['arg']).to eq(%w(1))
+      end
+    end
+
+    it 'coerces arrays with arg[] style' do
+      get('/coerce/array', 'arg[]' => ['1','2','3','4','5']) do |response|
+        expect(response.status).to eql 200
+        parsed_body = JSON.parse(response.body)
+        expect(parsed_body['arg']).to be_an(Array)
+        expect(parsed_body['arg']).to eq(%w(1 2 3 4 5))
+      end
+    end
+
+    it 'coerces arrays when hash is given' do
+      get('/coerce/array', arg: { foo: 'bar', chunky: 'bacon' } ) do |response|
+        expect(response.status).to eql 200
+        parsed_body = JSON.parse(response.body)
+        expect(parsed_body['arg']).to be_an(Array)
+        expect(parsed_body['arg']).to eq([['foo', 'bar'], ['chunky', 'bacon']])
+      end
+    end
+  end
+
+  describe 'Hash' do
+    it 'coerces hashes' do
+      get('/coerce/hash', arg: 'a:b,c:d') do |response|
+        expect(response.status).to eql 200
+        parsed_body = JSON.parse(response.body)
+        expect(parsed_body['arg']).to be_an(Hash)
+        expect(parsed_body['arg']).to eq({ 'a' => 'b', 'c' => 'd'})
+      end
+    end
+
+    it 'coerces hash when non valid arg is given' do
+      invalid_args = [
+        'not a hash',
+        ['1', '2', '3'],
+        999.99
+      ]
+
+      invalid_args.each do |arg|
+        get('/coerce/hash', arg: arg) do |response|
+          expect(response.status).to eql 200
+          parsed_body = JSON.parse(response.body)
+          expect(parsed_body['arg']).to be_an(Hash)
+        end
+      end
+    end
+  end
+
+  describe 'Boolean' do
+    it 'coerces truthy booleans to true' do
+      %w(1 true t yes y).each do |bool|
+        get('/coerce/boolean', arg: bool) do |response|
+          expect(response.status).to eql 200
+          expect(JSON.parse(response.body)['arg']).to be true
+        end
+      end
+    end
+
+    it 'coerces falsey booleans to false' do
+      %w(0 false f no n).each do |bool|
+        get('/coerce/boolean', arg: bool) do |response|
+          expect(response.status).to eql 200
+          expect(JSON.parse(response.body)['arg']).to be false
+          expect(JSON.parse(response.body)['arg']).to_not be_nil
+        end
+      end
+    end
+
+    it 'returns the default boolean false value' do
+      get('/default/boolean/false') do |response|
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['arg']).to be false
+      end
+    end
+
+    it 'returns the default boolean true value' do
+      get('/default/boolean/true') do |response|
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['arg']).to be true
+      end
+    end
+
+    it 'coerces truthy booleans to true when default is false' do
+      %w(1 true t yes y).each do |bool|
+        get('/default/boolean/false', arg: bool) do |response|
+          expect(response.status).to eql 200
+          expect(JSON.parse(response.body)['arg']).to be true
+        end
+      end
+    end
+
+    it 'coerces falsey booleans to false when default is true' do
+      %w(0 false f no n).each do |bool|
+        get('/default/boolean/true', arg: bool) do |response|
+          expect(response.status).to eql 200
+          expect(JSON.parse(response.body)['arg']).to be false
+          expect(JSON.parse(response.body)['arg']).to_not be_nil
+        end
+      end
+    end
+  end
+end