grape 0.8.0 → 0.9.0

data/spec/grape/dsl/middleware_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module Grape
+  module DSL
+    module MiddlewareSpec
+      class Dummy
+        include Grape::DSL::Middleware
+
+        def self.settings
+          @settings ||= Grape::Util::HashStack.new
+        end
+
+        def self.imbue(key, value)
+          settings.imbue(key, value)
+        end
+      end
+    end
+    describe Middleware do
+      subject { Class.new(MiddlewareSpec::Dummy) }
+      let(:proc) { ->() {} }
+
+      describe '.use' do
+        it 'adds a middleware' do
+          expect(subject).to receive(:imbue).with(:middleware, [[:my_middleware, :arg1, proc]])
+
+          subject.use :my_middleware, :arg1, &proc
+        end
+
+      end
+
+      describe '.middleware' do
+        it 'returns the middleware stack' do
+          subject.use :my_middleware, :arg1, &proc
+
+          expect(subject.middleware).to eq [[:my_middleware, :arg1, proc]]
+        end
+      end
+    end
+  end
+end

data/spec/grape/dsl/parameters_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+module Grape
+  module DSL
+    module ParametersSpec
+      class Dummy
+        include Grape::DSL::Parameters
+
+        def validate_attributes(*args)
+          @validate_attributes = *args
+        end
+
+        # rubocop:disable TrivialAccessors
+        def validate_attrs
+          @validate_attributes
+        end
+        # rubocop:enable TrivialAccessors
+
+        def push_declared_params(*args)
+          @push_declared_params = args
+        end
+
+        # rubocop:disable TrivialAccessors
+        def push_declared_paras
+          @push_declared_params
+        end
+        # rubocop:enable TrivialAccessors
+
+        def validates(*args)
+          @validates = *args
+        end
+
+        # rubocop:disable TrivialAccessors
+        def valids
+          @validates
+        end
+        # rubocop:enable TrivialAccessors
+      end
+    end
+
+    describe Parameters do
+      subject { ParametersSpec::Dummy.new }
+
+      xdescribe '#use' do
+        it 'does some thing'
+      end
+
+      xdescribe '#use_scope' do
+        it 'does some thing'
+      end
+
+      xdescribe '#includes' do
+        it 'does some thing'
+      end
+
+      describe '#requires' do
+        it 'adds a required parameter' do
+          subject.requires :id, type: Integer, desc: 'Identity.'
+
+          expect(subject.validate_attrs).to eq([[:id], { type: Integer, desc: 'Identity.' }])
+          expect(subject.push_declared_paras).to eq([[:id]])
+        end
+      end
+
+      describe '#optional' do
+        it 'adds an optional parameter' do
+          subject.optional :id, type: Integer, desc: 'Identity.'
+
+          expect(subject.valids).to eq([[:id], { type: Integer, desc: 'Identity.' }])
+          expect(subject.push_declared_paras).to eq([[:id]])
+        end
+      end
+
+      describe '#mutually_exclusive' do
+        it 'adds an mutally exclusive parameter validation' do
+          subject.mutually_exclusive :media, :audio
+
+          expect(subject.valids).to eq([[:media, :audio], { mutual_exclusion: true }])
+        end
+      end
+
+      describe '#exactly_one_of' do
+        it 'adds an exactly of one parameter validation' do
+          subject.exactly_one_of :media, :audio
+
+          expect(subject.valids).to eq([[:media, :audio], { exactly_one_of: true }])
+        end
+      end
+
+      describe '#at_least_one_of' do
+        it 'adds an at least one of parameter validation' do
+          subject.at_least_one_of :media, :audio
+
+          expect(subject.valids).to eq([[:media, :audio], { at_least_one_of: true }])
+        end
+      end
+
+      xdescribe '#group' do
+        it 'does some thing'
+      end
+
+      xdescribe '#params' do
+        it 'does some thing'
+      end
+
+    end
+  end
+end

data/spec/grape/dsl/request_response_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+module Grape
+  module DSL
+    module RequestResponseSpec
+      class Dummy
+        include Grape::DSL::RequestResponse
+
+        def self.settings
+          @settings ||= Grape::Util::HashStack.new
+        end
+
+        def self.set(key, value)
+          settings[key.to_sym] = value
+        end
+
+        def self.imbue(key, value)
+          settings.imbue(key, value)
+        end
+      end
+    end
+
+    describe RequestResponse do
+      subject { Class.new(RequestResponseSpec::Dummy) }
+      let(:c_type) { 'application/json' }
+      let(:format) { 'txt' }
+
+      describe '.default_format' do
+        it 'sets the default format' do
+          expect(subject).to receive(:set).with(:default_format, :format)
+          subject.default_format :format
+        end
+
+        it 'returns the format without paramter' do
+          subject.default_format :format
+
+          expect(subject.default_format).to eq :format
+        end
+      end
+
+      describe '.format' do
+        it 'sets a new format' do
+          expect(subject).to receive(:set).with(:format, format.to_sym)
+          expect(subject).to receive(:set).with(:default_error_formatter, Grape::ErrorFormatter::Txt)
+
+          subject.format format
+        end
+      end
+
+      describe '.formatter' do
+        it 'sets the formatter for a content type' do
+          expect(subject.settings).to receive(:imbue).with(:formatters, c_type.to_sym => :formatter)
+          subject.formatter c_type, :formatter
+        end
+      end
+
+      describe '.parser' do
+        it 'sets a parser for a content type' do
+          expect(subject.settings).to receive(:imbue).with(:parsers, c_type.to_sym => :parser)
+          subject.parser c_type, :parser
+        end
+      end
+
+      describe '.default_error_formatter' do
+        it 'sets a new error formatter' do
+          expect(subject).to receive(:set).with(:default_error_formatter, Grape::ErrorFormatter::Json)
+          subject.default_error_formatter :json
+        end
+      end
+
+      describe '.error_formatter' do
+        it 'sets a error_formatter' do
+          format = 'txt'
+          expect(subject.settings).to receive(:imbue).with(:error_formatters, format.to_sym => :error_formatter)
+          subject.error_formatter format, :error_formatter
+        end
+
+        it 'understands syntactic sugar' do
+          expect(subject.settings).to receive(:imbue).with(:error_formatters, format.to_sym => :error_formatter)
+          subject.error_formatter format, with: :error_formatter
+        end
+      end
+
+      describe '.content_type' do
+        it 'sets a content type for a format' do
+          expect(subject.settings).to receive(:imbue).with(:content_types, format.to_sym => c_type)
+          subject.content_type format, c_type
+        end
+      end
+
+      describe '.content_types' do
+        it 'returns all content types' do
+          expect(subject.content_types).to eq(xml: "application/xml",
+                                              serializable_hash: "application/json",
+                                              json: "application/json",
+                                              jsonapi: "application/vnd.api+json",
+                                              atom: "application/atom+xml",
+                                              rss: "application/rss+xml",
+                                              txt: "text/plain")
+        end
+      end
+
+      describe '.default_error_status' do
+        it 'sets a default error status' do
+          expect(subject).to receive(:set).with(:default_error_status, 500)
+          subject.default_error_status 500
+        end
+      end
+
+      xdescribe '.rescue_from' do
+        it 'does some thing'
+      end
+
+      describe '.represent' do
+        it 'sets a presenter for a class' do
+          presenter = Class.new
+          expect(subject).to receive(:imbue).with(:representations, ThisClass: presenter)
+          subject.represent :ThisClass, with: presenter
+        end
+      end
+    end
+  end
+end

data/spec/grape/dsl/routing_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+module Grape
+  module DSL
+    module RoutingSpec
+      class Dummy
+        include Grape::DSL::Routing
+      end
+    end
+
+    describe Routing do
+      subject { Class.new(RoutingSpec::Dummy) }
+      let(:proc) { ->() {} }
+      let(:options) { { a: :b } }
+      let(:path) { '/dummy' }
+
+      xdescribe '.version' do
+        it 'does some thing'
+      end
+
+      describe '.prefix' do
+        it 'sets a prefix for route' do
+          prefix = '/api'
+          expect(subject).to receive(:set).with(:root_prefix, prefix)
+          subject.prefix prefix
+        end
+      end
+
+      describe '.do_not_route_head!' do
+        it 'sets do not route head option' do
+          expect(subject).to receive(:set).with(:do_not_route_head, true)
+          subject.do_not_route_head!
+        end
+      end
+
+      describe '.do_not_route_options!' do
+        it 'sets do not route options option' do
+          expect(subject).to receive(:set).with(:do_not_route_options, true)
+          subject.do_not_route_options!
+        end
+      end
+
+      xdescribe '.mount' do
+        it 'does some thing'
+      end
+      xdescribe '.route' do
+        it 'does some thing'
+      end
+
+      describe '.get' do
+        it 'delegates to .route' do
+          expect(subject).to receive(:route).with('GET', path, options)
+          subject.get path, options, &proc
+        end
+      end
+
+      describe '.post' do
+        it 'delegates to .route' do
+          expect(subject).to receive(:route).with('POST', path, options)
+          subject.post path, options, &proc
+        end
+      end
+
+      describe '.put' do
+        it 'delegates to .route' do
+          expect(subject).to receive(:route).with('PUT', path, options)
+          subject.put path, options, &proc
+        end
+      end
+
+      describe '.head' do
+        it 'delegates to .route' do
+          expect(subject).to receive(:route).with('HEAD', path, options)
+          subject.head path, options, &proc
+        end
+      end
+
+      describe '.delete' do
+        it 'delegates to .route' do
+          expect(subject).to receive(:route).with('DELETE', path, options)
+          subject.delete path, options, &proc
+        end
+      end
+
+      describe '.options' do
+        it 'delegates to .route' do
+          expect(subject).to receive(:route).with('OPTIONS', path, options)
+          subject.options path, options, &proc
+        end
+      end
+
+      describe '.patch' do
+        it 'delegates to .route' do
+          expect(subject).to receive(:route).with('PATCH', path, options)
+          subject.patch path, options, &proc
+        end
+      end
+
+      xdescribe '.namespace' do
+        it 'does some thing'
+      end
+
+      xdescribe '.group' do
+        it 'does some thing'
+      end
+
+      xdescribe '.resource' do
+        it 'does some thing'
+      end
+
+      xdescribe '.resources' do
+        it 'does some thing'
+      end
+
+      xdescribe '.segment' do
+        it 'does some thing'
+      end
+
+      xdescribe '.routes' do
+        it 'does some thing'
+      end
+
+      xdescribe '.route_param' do
+        it 'does some thing'
+      end
+
+      xdescribe '.versions' do
+        it 'does some thing'
+      end
+    end
+  end
+end

data/spec/grape/dsl/validations_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module Grape
+  module DSL
+    module ValidationsSpec
+      class Dummy
+        include Grape::DSL::Validations
+
+        def self.settings
+          @settings ||= Grape::Util::HashStack.new
+        end
+      end
+    end
+
+    describe Validations do
+      subject { ValidationsSpec::Dummy }
+
+      describe '.reset_validations!' do
+        before do
+          subject.settings.peek[:declared_params] = ['dummy']
+          subject.settings.peek[:validations] = ['dummy']
+          subject.reset_validations!
+        end
+
+        it 'resets declared params' do
+          expect(subject.settings.peek[:declared_params]).to be_empty
+        end
+
+        it 'resets validations' do
+          expect(subject.settings.peek[:validations]).to be_empty
+        end
+      end
+
+      describe '.params' do
+        it 'returns a ParamsScope' do
+          expect(subject.params).to be_a Grape::Validations::ParamsScope
+        end
+
+        it 'evaluates block' do
+          expect { subject.params { raise 'foo' } }.to raise_error RuntimeError, 'foo'
+        end
+      end
+
+      describe '.document_attribute' do
+        before do
+          subject.document_attribute([full_name: 'xxx'], foo: 'bar')
+        end
+
+        it 'creates last_description' do
+          expect(subject.instance_variable_get(:'@last_description')).to eq(params: { 'xxx' => { foo: 'bar' } })
+        end
+      end
+    end
+  end
+end