gitlab-grape-swagger 1.5.0

data/spec/lib/optional_object_spec.rb

@@ -0,0 +1,47 @@
+# 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

@@ -0,0 +1,68 @@
+# 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
+  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

@@ -0,0 +1,101 @@
+# 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, route.path.dup, 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, route.path.dup, options)).to eql ['Thing', '/v1/thing']
+          route.path = '/{version}/thing/foo(.json)'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Foo', '/v1/thing/foo']
+          route.path = '/{version}/thing(.:format)'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Thing', '/v1/thing']
+          route.path = '/{version}/thing/foo(.:format)'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Foo', '/v1/thing/foo']
+          route.path = '/{version}/thing/:id'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Thing', '/v1/thing/{id}']
+          route.path = '/{version}/thing/foo/:id'
+          expect(subject.build(route, route.path.dup, 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, route.path.dup, options)).to eql ['Thing', '/thing']
+          route.path = '/{version}/thing/foo(.json)'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Foo', '/thing/foo']
+          route.path = '/{version}/thing(.:format)'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Thing', '/thing']
+          route.path = '/{version}/thing/foo(.:format)'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Foo', '/thing/foo']
+          route.path = '/{version}/thing/:id'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Thing', '/thing/{id}']
+          route.path = '/{version}/thing/foo/:id'
+          expect(subject.build(route, route.path.dup, 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, route.path.dup, options)).to eql ['Thing', '/thing']
+          route.path = '/{version}/thing/foo(.json)'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Foo', '/thing/foo']
+          route.path = '/{version}/thing(.:format)'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Thing', '/thing']
+          route.path = '/{version}/thing/foo(.:format)'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Foo', '/thing/foo']
+          route.path = '/{version}/thing/:id'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Thing', '/thing/{id}']
+          route.path = '/{version}/thing/foo/:id'
+          expect(subject.build(route, route.path.dup, 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, route.path.dup, options)).to eql ['Thing', '/thing']
+          route.path = '/{version}/thing/foo(.json)'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Foo', '/thing/foo']
+          route.path = '/{version}/thing(.:format)'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Thing', '/thing']
+          route.path = '/{version}/thing/foo(.:format)'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Foo', '/thing/foo']
+          route.path = '/{version}/thing/:id'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Thing', '/thing/{id}']
+          route.path = '/{version}/thing/foo/:id'
+          expect(subject.build(route, route.path.dup, options)).to eql ['Foo', '/thing/foo/{id}']
+        end
+      end
+    end
+  end
+end

data/spec/lib/produces_consumes_spec.rb

@@ -0,0 +1,116 @@
+# 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

@@ -0,0 +1,80 @@
+# 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

@@ -0,0 +1,28 @@
+# 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

@@ -0,0 +1,39 @@
+# 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

@@ -0,0 +1,23 @@
+# 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

@@ -0,0 +1,13 @@
+# 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

@@ -0,0 +1,23 @@
+# 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)