grape-swagger 0.11.0 → 0.20.0

data/spec/lib/optional_object_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe GrapeSwagger::DocMethods::OptionalObject do
+  subject { described_class }
+
+  specify { expect(subject).to eql GrapeSwagger::DocMethods::OptionalObject }
+  specify { expect(subject).to respond_to :build }
+
+  describe 'build' do
+    let(:key) { :bar }
+    let(:request) { 'somes/request/string' }
+
+    describe 'no option given for key' do
+      let(:options) { {foo: 'foo' }}
+      specify do
+        expect(subject.build(key, options)).to be_nil
+        expect(subject.build(key, options, request)).to eql request
+      end
+    end
+
+    let(:value) { 'some optional value' }
+
+    describe 'option is a string' do
+      let(:options) { {bar: value }}
+      specify do
+        expect(subject.build(key, options)).to eql value
+        expect(subject.build(key, options, request)).to eql value
+      end
+    end
+
+    describe 'option is a proc' do
+      let(:options) { {bar: -> { value } }}
+      specify do
+        expect(subject.build(key, options)).to eql value
+        expect(subject.build(key, options, request)).to eql value
+      end
+    end
+  end
+
+end

data/spec/lib/path_string_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe GrapeSwagger::DocMethods::PathString do
+  subject { described_class }
+
+  specify { expect(subject).to eql GrapeSwagger::DocMethods::PathString }
+  specify { expect(subject).to respond_to :build }
+
+  describe 'operation_id_object' do
+    describe 'version' do
+      describe 'defaults: not given, false' do
+        let(:options) {{ add_version: false }}
+
+        specify do
+          expect(subject.build('/thing(.json)', options)).to eql ['Thing', '/thing']
+          expect(subject.build('/thing/foo(.json)', options)).to eql ['Foo', '/thing/foo']
+          expect(subject.build('/thing(.:format)', options)).to eql ['Thing', '/thing']
+          expect(subject.build('/thing/foo(.:format)', options)).to eql ['Foo', '/thing/foo']
+          expect(subject.build('/thing/:id', options)).to eql ['Thing', '/thing/{id}']
+          expect(subject.build('/thing/foo/:id', options)).to eql ['Foo', '/thing/foo/{id}']
+        end
+      end
+
+      describe 'defaults: given, true' do
+        let(:options) {{ version: 'v1', add_version: true }}
+
+        specify do
+          expect(subject.build('/{version}/thing(.json)', options)).to eql ['Thing', '/v1/thing']
+          expect(subject.build('/{version}/thing/foo(.json)', options)).to eql ['Foo', '/v1/thing/foo']
+          expect(subject.build('/{version}/thing(.:format)', options)).to eql ['Thing', '/v1/thing']
+          expect(subject.build('/{version}/thing/foo(.:format)', options)).to eql ['Foo', '/v1/thing/foo']
+          expect(subject.build('/{version}/thing/:id', options)).to eql ['Thing', '/v1/thing/{id}']
+          expect(subject.build('/{version}/thing/foo/:id', options)).to eql ['Foo', '/v1/thing/foo/{id}']
+        end
+      end
+    end
+  end
+end

data/spec/lib/produces_consumes_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe GrapeSwagger::DocMethods::ProducesConsumes do
+  describe ":json (default)" do
+    subject { described_class.call }
+
+    specify do
+      expect(subject).to eql( ['application/json'] )
+    end
+  end
+
+  describe "accept symbols of" do
+    describe "single" do
+      subject { described_class.call(:xml) }
+
+      specify do
+        expect(subject).to eql( ['application/xml'] )
+      end
+    end
+
+    describe "multiple" do
+      subject { described_class.call(:xml, :serializable_hash, :json, :binary, :txt) }
+
+      specify do
+        expect(subject).to eql( [
+          'application/xml',
+          'application/json',
+          'application/octet-stream',
+          'text/plain'
+        ] )
+      end
+    end
+  end
+
+  describe "accept mime_types of" do
+    describe "single" do
+      subject { described_class.call('application/xml') }
+
+      specify do
+        expect(subject).to eql( ['application/xml'] )
+      end
+    end
+
+    describe "multiple" do
+      subject { described_class.call(
+        'application/xml',
+        'application/json',
+        'application/octet-stream',
+        'text/plain'
+      ) }
+
+      specify do
+        expect(subject).to eql( [
+          'application/xml',
+          'application/json',
+          'application/octet-stream',
+          'text/plain'
+        ] )
+      end
+    end
+  end
+
+  describe "mix it up" do
+    subject { described_class.call(
+      :xml,
+      :serializable_hash,
+      'application/json',
+      'application/octet-stream',
+      :txt
+    ) }
+
+    specify do
+      expect(subject).to eql( [
+        'application/xml',
+        'application/json',
+        'application/octet-stream',
+        'text/plain'
+      ] )
+    end
+
+    subject { described_class.call( [
+      :xml,
+      :serializable_hash,
+      'application/json',
+      'application/octet-stream',
+      :txt
+    ] ) }
+
+    specify do
+      expect(subject).to eql( [
+        'application/xml',
+        'application/json',
+        'application/octet-stream',
+        'text/plain'
+      ] )
+    end
+  end
+end

data/spec/markdown/kramdown_adapter_spec.rb

@@ -15,20 +15,13 @@ describe GrapeSwagger::Markdown::KramdownAdapter do
 
       expect(adapter.options).to eq(options)
     end
-
-    it 'raises an GrapeSwagger::Errors::MarkdownDependencyMissingError if module can not be required' do
-      pending
-      expect_any_instance_of(Kernel).to receive(:require).with('kramdown').and_raise(LoadError)
-
-      expect { GrapeSwagger::Markdown::KramdownAdapter.new }.to raise_error(GrapeSwagger::Errors::MarkdownDependencyMissingError, 'Missing required dependency: kramdown')
-    end
   end
 
   context 'markdown' do
     it 'marks down with the configured options' do
-      text = '# hello world #'
+      text = '# hello world'
       options = { input: 'GFM', enable_coderay: true, auto_ids: false, hard_wrap: true }
-      expect(Kramdown::Document).to receive(:new).with(text, options).and_call_original
+      expect(GrapeSwagger::Markdown::KramdownAdapter).to receive(:new).with(options).and_call_original
 
       output = GrapeSwagger::Markdown::KramdownAdapter.new(options).markdown(text)
 

data/spec/markdown/redcarpet_adapter_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe GrapeSwagger::Markdown::RedcarpetAdapter, unless: RUBY_PLATFORM.eql?('java') do
+describe GrapeSwagger::Markdown::RedcarpetAdapter, unless: RUBY_PLATFORM.eql?('java') || RUBY_ENGINE.eql?('rbx') do
   context 'initialization' do
     context 'initialization' do
       it 'uses fenced_code_blocks, auto_links and rouge as default.' do
@@ -30,19 +30,13 @@ describe GrapeSwagger::Markdown::RedcarpetAdapter, unless: RUBY_PLATFORM.eql?('j
         expect(adapter.extension_options).to eq(extensions)
         expect(adapter.render_options).to eq(no_links: true)
       end
-
-      it 'raises an GrapeSwagger::Errors::MarkdownDependencyMissingError if module can not be required.' do
-        expect_any_instance_of(Kernel).to receive(:require).with('redcarpet').and_raise(LoadError)
-
-        expect { GrapeSwagger::Markdown::RedcarpetAdapter.new }.to raise_error(GrapeSwagger::Errors::MarkdownDependencyMissingError, 'Missing required dependency: redcarpet')
-      end
     end
 
     context 'markdown' do
       it 'marks down with the configured options' do
         text = '# hello world #'
         extensions = { fenced_code_blocks: true, autolink: true }
-        render_options = { highlighter: :none, no_links: true }
+        render_options = { highlighter: :none, no_links: true, highlighter: :none }
         expect_any_instance_of(Redcarpet::Markdown).to receive(:render).with(text).and_call_original
 
         output = GrapeSwagger::Markdown::RedcarpetAdapter.new(extensions: extensions, render_options: render_options).markdown(text)
@@ -60,14 +54,6 @@ describe GrapeSwagger::Markdown::RedcarpetAdapter, unless: RUBY_PLATFORM.eql?('j
         expect(renderer.superclass).to be(Redcarpet::Render::HTML)
       end
 
-      it 'throws an error when rouge syntax highlighter cant be included' do
-        adapter = GrapeSwagger::Markdown::RedcarpetAdapter.new
-
-        expect_any_instance_of(Kernel).to receive(:require).with('rouge').and_raise(LoadError)
-
-        expect { adapter.send(:new_redcarpet_renderer, :rouge) }.to raise_error(GrapeSwagger::Errors::MarkdownDependencyMissingError, 'Missing required dependency: rouge')
-      end
-
       it 'returns a default syntax highlighter' do
         adapter = GrapeSwagger::Markdown::RedcarpetAdapter.new
         renderer = adapter.send(:new_redcarpet_renderer, :none)

data/spec/spec_helper.rb

@@ -1,29 +1,23 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'support'))
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+Dir[File.join(Dir.getwd, 'spec/support/**/*.rb')].each { |f| require f }
 
 require 'grape'
 require 'grape-swagger'
 require 'grape-entity'
 
-require 'rubygems'
-require 'bundler'
-
-require 'json'
-
 Bundler.setup :default, :test
 
+require 'rack'
 require 'rack/test'
 
-require 'i18n_helper'
-
 RSpec.configure do |config|
   require 'rspec/expectations'
-  require 'rspec/support'
-
   config.include RSpec::Matchers
   config.mock_with :rspec
   config.include Rack::Test::Methods
   config.raise_errors_for_deprecations!
-  config.include I18nHelper
+
+  config.order = 'random'
+  config.seed = 40834
 end

data/spec/support/api_swagger_v2_result.rb

@@ -0,0 +1,204 @@
+RSpec.shared_context "swagger example" do
+
+  before :all do
+    module Entities
+      class Something < Grape::Entity
+        expose :id, documentation: { type: Integer, desc: 'Identity of Something' }
+        expose :text, documentation: { type: String, desc: 'Content of something.' }
+        expose :links, documentation: { type: 'link', is_array: true }
+        expose :others, documentation: { type: 'text', is_array: false }
+      end
+
+      class EnumValues < Grape::Entity
+        expose :gender, documentation: { type: 'string', desc: 'Content of something.', values: %w(Male Female) }
+        expose :number, documentation: { type: 'integer', desc: 'Content of something.', values: [1, 2]  }
+      end
+
+
+      class AliasedThing < Grape::Entity
+        expose :something, as: :post, using: Entities::Something, documentation: { type: 'Something', desc: 'Reference to something.' }
+      end
+
+      class FourthLevel < Grape::Entity
+        expose :text, documentation: { type: 'string' }
+      end
+
+      class ThirdLevel < Grape::Entity
+        expose :parts, using: Entities::FourthLevel, documentation: { type: 'FourthLevel' }
+      end
+
+      class SecondLevel < Grape::Entity
+        expose :parts, using: Entities::ThirdLevel, documentation: { type: 'ThirdLevel' }
+      end
+
+      class FirstLevel < Grape::Entity
+        expose :parts, using: Entities::SecondLevel, documentation: { type: 'SecondLevel' }
+      end
+
+      class QueryInputElement < Grape::Entity
+        expose :key, documentation: {
+          type: String, desc: 'Name of parameter', required: true }
+        expose :value, documentation: {
+          type: String, desc: 'Value of parameter', required: true }
+      end
+
+      class QueryInput < Grape::Entity
+        expose :elements, using: Entities::QueryInputElement, documentation: {
+          type: 'QueryInputElement',
+          desc: 'Set of configuration',
+          param_type: 'body',
+          is_array: true,
+          required: true
+        }
+      end
+
+      class ApiError < Grape::Entity
+        expose :code, documentation: { type: Integer, desc: 'status code' }
+        expose :message, documentation: { type: String, desc: 'error message' }
+      end
+    end
+  end
+
+  let(:swagger_json) do
+    {
+      "info"=>{
+        "title"=>"The API title to be displayed on the API homepage.",
+        "description"=>"A description of the API.",
+        "termsOfServiceUrl"=>"www.The-URL-of-the-terms-and-service.com",
+        "contact"=>{"name"=>"Contact name", "email"=>"Contact@email.com", "url"=>"Contact URL"},
+        "license"=>{"name"=>"The name of the license.", "url"=>"www.The-URL-of-the-license.org"},
+        "version"=>"v1"
+      },
+      "swagger"=>"2.0",
+      "produces"=>["application/json"],
+      "host"=>"example.org",
+      "basePath"=>"/api",
+      "tags"=>[
+        {"name"=>"other_thing", "description"=>"Operations about other_things"},
+        {"name"=>"thing", "description"=>"Operations about things"},
+        {"name"=>"thing2", "description"=>"Operations about thing2s"},
+        {"name"=>"dummy", "description"=>"Operations about dummies"}
+      ],
+      "schemes"=>["https", "http"],
+      "paths"=>{
+        "/v3/other_thing/{elements}"=>{
+          "get"=>{
+            "description"=>"nested route inside namespace",
+            "produces"=>["application/json"],
+            "parameters"=>[{"in"=>"body", "name"=>"elements", "description"=>"Set of configuration", "type"=>"array", "items"=>{"type"=>"string"}, "required"=>true}],
+            "responses"=>{"200"=>{"description"=>"nested route inside namespace", "schema"=>{"$ref"=>"#/definitions/QueryInput"}}},
+            "tags"=>["other_thing"],
+            "operationId"=>"getV3OtherThingElements",
+            "x-amazon-apigateway-auth"=>{"type"=>"none"},
+            "x-amazon-apigateway-integration"=>{"type"=>"aws", "uri"=>"foo_bar_uri", "httpMethod"=>"get"}
+          }
+        },
+        "/thing"=>{
+          "get"=>{
+            "description"=>"This gets Things.",
+            "produces"=>["application/json"],
+            "parameters"=>[
+              {"in"=>"query", "name"=>"id", "description"=>"Identity of Something", "type"=>"integer", "format"=>"int32", "required"=>false},
+              {"in"=>"query", "name"=>"text", "description"=>"Content of something.", "type"=>"string", "required"=>false},
+              {"in"=>"formData", "name"=>"links", "description"=>nil, "type"=>"array", "items"=>{"type"=>"link"}, "required"=>false},
+              {"in"=>"query", "name"=>"others", "description"=>nil, "type"=>"text", "required"=>false}
+            ],
+            "responses"=>{"200"=>{"description"=>"This gets Things.", "schema"=>{"$ref"=>"#/definitions/Thing"}}, "401"=>{"description"=>"Unauthorized", "schema"=>{"$ref"=>"#/definitions/ApiError"}}},
+            "tags"=>["thing"],
+            "operationId"=>"getThing"
+          },
+          "post"=>{
+            "description"=>"This creates Thing.",
+            "produces"=>["application/json"],
+            "consumes"=>["application/json"],
+            "parameters"=>[
+              {"in"=>"formData", "name"=>"text", "description"=>"Content of something.", "type"=>"string", "required"=>true},
+              {"in"=>"formData", "name"=>"links", "description"=>nil, "type"=>"array", "items"=>{"type"=>"string"}, "required"=>true}
+            ],
+            "responses"=>{"201"=>{"description"=>"This creates Thing.", "schema"=>{"$ref"=>"#/definitions/Something"}}, "422"=>{"description"=>"Unprocessible Entity"}},
+            "tags"=>["thing"],
+            "operationId"=>"postThing"
+          }
+        },
+        "/thing/{id}"=>{
+          "get"=>{
+            "description"=>"This gets Thing.",
+            "produces"=>["application/json"],
+            "parameters"=>[{"in"=>"path", "name"=>"id", "description"=>nil, "type"=>"integer", "format"=>"int32", "required"=>true}],
+            "responses"=>{"200"=>{"description"=>"getting a single thing", "schema"=>{"$ref"=>"#/definitions/Thing"}}, "401"=>{"description"=>"Unauthorized"}},
+            "tags"=>["thing"],
+            "operationId"=>"getThingId"
+          },
+          "put"=>{
+            "description"=>"This updates Thing.",
+            "produces"=>["application/json"],
+            "consumes"=>["application/json"],
+            "parameters"=>[
+              {"in"=>"path", "name"=>"id", "description"=>nil, "type"=>"integer", "format"=>"int32", "required"=>true},
+              {"in"=>"formData", "name"=>"text", "description"=>"Content of something.", "type"=>"string", "required"=>false},
+              {"in"=>"formData", "name"=>"links", "description"=>nil, "type"=>"array", "items"=>{"type"=>"string"}, "required"=>false}
+            ],
+            "responses"=>{"200"=>{"description"=>"This updates Thing.", "schema"=>{"$ref"=>"#/definitions/Something"}}},
+            "tags"=>["thing"],
+            "operationId"=>"putThingId"
+          },
+          "delete"=>{
+            "description"=>"This deletes Thing.",
+            "produces"=>["application/json"],
+            "parameters"=>[{"in"=>"path", "name"=>"id", "description"=>nil, "type"=>"integer", "format"=>"int32", "required"=>true}],
+            "responses"=>{"200"=>{"description"=>"This deletes Thing.", "schema"=>{"$ref"=>"#/definitions/Something"}}},
+            "tags"=>["thing"],
+            "operationId"=>"deleteThingId"
+          }
+        },
+        "/thing2"=>{
+          "get"=>{
+            "description"=>"This gets Things.",
+            "produces"=>["application/json"],
+            "responses"=>{"200"=>{"description"=>"get Horses", "schema"=>{"$ref"=>"#/definitions/Something"}}, "401"=>{"description"=>"HorsesOutError", "schema"=>{"$ref"=>"#/definitions/ApiError"}}},
+            "tags"=>["thing2"],
+            "operationId"=>"getThing2"
+          }
+        },
+        "/dummy/{id}"=>{
+          "delete"=>{
+            "description"=>"dummy route.",
+            "produces"=>["application/json"],
+            "parameters"=>[{"in"=>"path", "name"=>"id", "description"=>nil, "type"=>"integer", "format"=>"int32", "required"=>true}],
+            "responses"=>{"204"=>{"description"=>"dummy route."}, "401"=>{"description"=>"Unauthorized"}},
+            "tags"=>["dummy"],
+            "operationId"=>"deleteDummyId"
+          }
+        }
+      },
+      "definitions"=>{
+        "QueryInput"=>{
+          "type"=>"object",
+          "properties"=>{"elements"=>{"type"=>"array", "items"=>{"$ref"=>"#/definitions/QueryInputElement"}}},
+          "description"=>"nested route inside namespace"},
+        "QueryInputElement"=>{
+          "type"=>"object",
+          "properties"=>{"key"=>{"type"=>"string"}, "value"=>{"type"=>"string"}}},
+        "Thing"=>{
+          "type"=>"object",
+          "properties"=>{"id"=>{"type"=>"integer", "format"=>"int32"}, "text"=>{"type"=>"string"}, "links"=>{"type"=>"link"}, "others"=>{"type"=>"text"}},
+          "description"=>"This gets Thing."},
+        "ApiError"=>{
+          "type"=>"object",
+          "properties"=>{"code"=>{"type"=>"integer", "format"=>"int32"}, "message"=>{"type"=>"string"}},
+          "description"=>"This gets Things."},
+        "Something"=>{
+          "type"=>"object",
+          "properties"=>{"id"=>{"type"=>"integer", "format"=>"int32"}, "text"=>{"type"=>"string"}, "links"=>{"type"=>"link"}, "others"=>{"type"=>"text"}},
+          "description"=>"This gets Things."
+        }
+      }
+    }
+  end
+
+  let(:http_verbs) { %w[get post put delete]}
+end
+
+def mounted_paths
+  %w[ /thing /other_thing /dummy ]
+end