grape-swagger 1.6.1 → 2.0.0

data/spec/lib/optional_object_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-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) { :host }
-    let!(:request) { Rack::Request.new(Rack::MockRequest.env_for('http://example.com:8080/')) }
-
-    describe 'no option given for host, take from request' do
-      let(:options) { { foo: 'foo' } }
-      specify do
-        expect(subject.build(key, options, request)).to eql request.host_with_port
-      end
-    end
-
-    let(:value) { 'grape-swagger.example.com' }
-
-    describe 'option is a string' do
-      let(:options) { { host: value } }
-      specify do
-        expect(subject.build(key, options, request)).to eql value
-      end
-    end
-
-    describe 'option is a lambda' do
-      let(:options) { { host: -> { value } } }
-      specify do
-        expect(subject.build(key, options, request)).to eql value
-      end
-    end
-
-    describe 'option is a proc' do
-      let(:options) do
-        { host: proc { |request| request.host =~ /^example/ ? '/api-example' : '/api' } }
-      end
-      specify do
-        expect(subject.build(key, options, request)).to eql '/api-example'
-      end
-    end
-  end
-end

data/spec/lib/parse_params_spec.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe GrapeSwagger::DocMethods::ParseParams do
-  subject { described_class }
-  let(:start_value) { -5 }
-  let(:end_value) { 5 }
-
-  describe '#parse_range_values' do
-    specify do
-      parsed_range = subject.send(:parse_range_values, start_value..end_value)
-      expect(parsed_range).to eql(minimum: start_value, maximum: end_value)
-    end
-
-    describe 'endless range' do
-      specify do
-        parsed_range = subject.send(:parse_range_values, start_value..)
-        expect(parsed_range).to eql(minimum: start_value)
-      end
-    end
-
-    describe 'beginless range' do
-      specify do
-        parsed_range = subject.send(:parse_range_values, ..end_value)
-        expect(parsed_range).to eql(maximum: end_value)
-      end
-    end
-  end
-
-  describe '#parse_enum_or_range_values' do
-    describe 'value as Range' do
-      describe 'first Integer' do
-        specify do
-          parsed_range = subject.send(:parse_enum_or_range_values, start_value..end_value)
-          expect(parsed_range).to eql(minimum: start_value, maximum: end_value)
-        end
-      end
-
-      describe 'first String' do
-        specify do
-          parsed_range = subject.send(:parse_enum_or_range_values, 'a'..'z')
-          expect(parsed_range).to be_nil
-        end
-      end
-    end
-
-    describe 'value as Proc' do
-      describe 'as Range' do
-        let(:values) { proc { start_value..end_value } }
-        specify do
-          parsed_range = subject.send(:parse_enum_or_range_values, values)
-          expect(parsed_range).to eql(minimum: start_value, maximum: end_value)
-        end
-      end
-
-      describe 'as Array' do
-        let(:values) { proc { %w[a b c] } }
-        specify do
-          parsed_range = subject.send(:parse_enum_or_range_values, values)
-          expect(parsed_range).to eql(enum: %w[a b c])
-        end
-      end
-
-      describe 'with arity one' do
-        let(:values) { proc { |v| v < 25 } }
-        specify do
-          parsed_range = subject.send(:parse_enum_or_range_values, values)
-          expect(parsed_range).to be_nil
-        end
-      end
-    end
-
-    describe 'values as Array -> enums' do
-      let(:values) { %w[a b c] }
-      specify do
-        parsed_range = subject.send(:parse_enum_or_range_values, values)
-        expect(parsed_range).to eql(enum: %w[a b c])
-      end
-    end
-  end
-end

data/spec/lib/path_string_spec.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-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 'path_string_object' do
-    specify 'The original route path is not mutated' do
-      route = Struct.new(:version, :path).new
-      route.path = '/foo/:dynamic/bar'
-      subject.build(route, add_version: true)
-      expect(route.path).to eq '/foo/:dynamic/bar'
-    end
-
-    describe 'version' do
-      describe 'defaults: given, true' do
-        let(:options) { { add_version: true } }
-        let(:route) { Struct.new(:version, :path).new('v1') }
-
-        specify 'The returned path includes version' do
-          route.path = '/{version}/thing(.json)'
-          expect(subject.build(route, options)).to eql ['Thing', '/v1/thing']
-          route.path = '/{version}/thing/foo(.json)'
-          expect(subject.build(route, options)).to eql ['Foo', '/v1/thing/foo']
-          route.path = '/{version}/thing(.:format)'
-          expect(subject.build(route, options)).to eql ['Thing', '/v1/thing']
-          route.path = '/{version}/thing/foo(.:format)'
-          expect(subject.build(route, options)).to eql ['Foo', '/v1/thing/foo']
-          route.path = '/{version}/thing/:id'
-          expect(subject.build(route, options)).to eql ['Thing', '/v1/thing/{id}']
-          route.path = '/{version}/thing/foo/:id'
-          expect(subject.build(route, options)).to eql ['Foo', '/v1/thing/foo/{id}']
-        end
-      end
-
-      describe 'defaults: not given, both false' do
-        let(:options) { { add_version: false } }
-        let(:route) { Struct.new(:version, :path).new }
-
-        specify 'The returned path does not include version' do
-          route.path = '/{version}/thing(.json)'
-          expect(subject.build(route, options)).to eql ['Thing', '/thing']
-          route.path = '/{version}/thing/foo(.json)'
-          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo']
-          route.path = '/{version}/thing(.:format)'
-          expect(subject.build(route, options)).to eql ['Thing', '/thing']
-          route.path = '/{version}/thing/foo(.:format)'
-          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo']
-          route.path = '/{version}/thing/:id'
-          expect(subject.build(route, options)).to eql ['Thing', '/thing/{id}']
-          route.path = '/{version}/thing/foo/:id'
-          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo/{id}']
-        end
-      end
-
-      describe 'defaults: add_version false' do
-        let(:options) { { add_version: false } }
-        let(:route) { Struct.new(:version, :path).new('v1') }
-
-        specify 'The returned path does not include version' do
-          route.path = '/{version}/thing(.json)'
-          expect(subject.build(route, options)).to eql ['Thing', '/thing']
-          route.path = '/{version}/thing/foo(.json)'
-          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo']
-          route.path = '/{version}/thing(.:format)'
-          expect(subject.build(route, options)).to eql ['Thing', '/thing']
-          route.path = '/{version}/thing/foo(.:format)'
-          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo']
-          route.path = '/{version}/thing/:id'
-          expect(subject.build(route, options)).to eql ['Thing', '/thing/{id}']
-          route.path = '/{version}/thing/foo/:id'
-          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo/{id}']
-        end
-      end
-
-      describe 'defaults: root_version nil' do
-        let(:options) { { add_version: true } }
-        let(:route) { Struct.new(:version, :path).new }
-
-        specify 'The returned path does not include version' do
-          route.path = '/{version}/thing(.json)'
-          expect(subject.build(route, options)).to eql ['Thing', '/thing']
-          route.path = '/{version}/thing/foo(.json)'
-          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo']
-          route.path = '/{version}/thing(.:format)'
-          expect(subject.build(route, options)).to eql ['Thing', '/thing']
-          route.path = '/{version}/thing/foo(.:format)'
-          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo']
-          route.path = '/{version}/thing/:id'
-          expect(subject.build(route, options)).to eql ['Thing', '/thing/{id}']
-          route.path = '/{version}/thing/foo/:id'
-          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo/{id}']
-        end
-      end
-    end
-  end
-end

data/spec/lib/produces_consumes_spec.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-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 do
-        described_class.call(
-          'application/xml',
-          'application/json',
-          'application/octet-stream',
-          'text/plain'
-        )
-      end
-
-      specify do
-        expect(subject).to eql(
-          [
-            'application/xml',
-            'application/json',
-            'application/octet-stream',
-            'text/plain'
-          ]
-        )
-      end
-    end
-  end
-
-  describe 'mix it up' do
-    subject do
-      described_class.call(
-        :xml,
-        :serializable_hash,
-        'application/json',
-        'application/octet-stream',
-        :txt
-      )
-    end
-
-    specify do
-      expect(subject).to eql(
-        [
-          'application/xml',
-          'application/json',
-          'application/octet-stream',
-          'text/plain'
-        ]
-      )
-    end
-
-    subject do
-      described_class.call(
-        [
-          :xml,
-          :serializable_hash,
-          'application/json',
-          'application/octet-stream',
-          :txt
-        ]
-      )
-    end
-
-    specify do
-      expect(subject).to eql(
-        [
-          'application/xml',
-          'application/json',
-          'application/octet-stream',
-          'text/plain'
-        ]
-      )
-    end
-  end
-end

data/spec/lib/tag_name_description_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe GrapeSwagger::DocMethods::TagNameDescription do
-  describe '#build_memo' do
-    let(:tag) { 'some_string' }
-    subject { described_class.send(:build_memo, tag) }
-
-    specify do
-      expect(subject.keys).to eql %i[name description]
-      expect(subject).to eql(
-        name: tag,
-        description: "Operations about #{tag.pluralize}"
-      )
-    end
-  end
-
-  describe '#build' do
-    let(:object) { described_class.build(paths) }
-
-    describe 'empty paths' do
-      let(:paths) { {} }
-      specify do
-        expect(object).to eql([])
-      end
-    end
-
-    describe 'paths given' do
-      describe 'uniq as String' do
-        let(:paths) do
-          { key_1: { post: { tags: 'tags_given' } } }
-        end
-
-        specify do
-          expect(object).to eql [{ name: 'tags_given', description: 'Operations about tags_givens' }]
-        end
-      end
-
-      describe 'uniq as Array' do
-        let(:paths) do
-          { key_1: { post: { tags: ['tags_given'] } } }
-        end
-
-        specify do
-          expect(object).to eql [{ name: 'tags_given', description: 'Operations about tags_givens' }]
-        end
-      end
-
-      describe 'multiple' do
-        describe 'uniq key' do
-          let(:paths) do
-            {
-              key_1: { post: { tags: %w[tags_given another_tag_given] } }
-            }
-          end
-
-          specify do
-            expect(object).to eql [
-              { name: 'tags_given', description: 'Operations about tags_givens' },
-              { name: 'another_tag_given', description: 'Operations about another_tag_givens' }
-            ]
-          end
-        end
-        describe 'under different keys' do
-          let(:paths) do
-            {
-              key_1: { post: { tags: ['tags_given'] } },
-              key_2: { post: { tags: ['tags_given'] } }
-            }
-          end
-
-          specify do
-            expect(object).to eql [{ name: 'tags_given', description: 'Operations about tags_givens' }]
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/version_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe GrapeSwagger::DocMethods::Version do
-  let(:route) { OpenStruct.new(version: version) }
-  subject { described_class.get(route) }
-
-  describe 'grape 0.16.2 version' do
-    let(:version) { '[:v1, :v2]' }
-    it { is_expected.to be_a Array }
-    it { is_expected.to eql %i[v1 v2] }
-  end
-
-  describe 'newer grape versions' do
-    describe 'as String' do
-      let(:version) { 'v1' }
-      it { is_expected.to be_a String }
-      it { is_expected.to eql 'v1' }
-    end
-
-    describe 'as Array' do
-      let(:version) { %i[v1 v2] }
-      it { is_expected.to be_a Array }
-      it { is_expected.to eql %i[v1 v2] }
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-if RUBY_ENGINE == 'ruby'
-  require 'simplecov'
-  require 'coveralls'
-
-  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
-  Coveralls.wear!
-end
-
-$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
-
-MODEL_PARSER = ENV.key?('MODEL_PARSER') ? ENV['MODEL_PARSER'].to_s.downcase.sub('grape-swagger-', '') : 'mock'
-
-require 'grape'
-require 'grape-swagger'
-
-Dir[File.join(Dir.getwd, 'spec/support/*.rb')].each { |f| require f }
-require "grape-swagger/#{MODEL_PARSER}" if MODEL_PARSER != 'mock'
-require File.join(Dir.getwd, "spec/support/model_parsers/#{MODEL_PARSER}_parser.rb")
-
-require 'grape-entity'
-require 'grape-swagger-entity'
-
-Bundler.setup :default, :test
-
-require 'rack'
-require 'rack/test'
-
-RSpec.configure do |config|
-  require 'rspec/expectations'
-  config.include RSpec::Matchers
-  config.mock_with :rspec
-  config.include Rack::Test::Methods
-  config.raise_errors_for_deprecations!
-
-  config.order = 'random'
-  config.seed = 40_834
-end

data/spec/support/empty_model_parser.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Lint/EmptyClass
-class EmptyClass
-end
-# rubocop:enable Lint/EmptyClass
-
-module GrapeSwagger
-  class EmptyModelParser
-    attr_reader :model, :endpoint
-
-    def initialize(model, endpoint)
-      @model = model
-      @endpoint = endpoint
-    end
-
-    def call
-      {}
-    end
-  end
-end
-
-GrapeSwagger.model_parsers.register(GrapeSwagger::EmptyModelParser, EmptyClass)

data/spec/support/grape_version.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-class GrapeVersion
-  class << self
-    def current_version
-      Grape::VERSION
-    end
-
-    def satisfy?(requirement)
-      Gem::Dependency.new('grape-test', requirement).match?('grape-test', current_version)
-    end
-  end
-end

data/spec/support/mock_parser.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module GrapeSwagger
-  class MockParser
-    attr_reader :model, :endpoint
-
-    def initialize(model, endpoint)
-      @model = model
-      @endpoint = endpoint
-    end
-
-    def call
-      {
-        mock_data: {
-          type: :string,
-          description: "it's a mock"
-        }
-      }
-    end
-  end
-end
-
-GrapeSwagger.model_parsers.register(GrapeSwagger::MockParser, OpenStruct)