grape-swagger 1.6.0 → 2.0.0

data/spec/lib/extensions_spec.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe GrapeSwagger::DocMethods::Extensions do
-  context 'it should not break method introspection' do
-    describe '.method' do
-      describe 'method introspection' do
-        specify do
-          expect(described_class.method(described_class.methods.first)).to be_a(Method)
-        end
-      end
-    end
-  end
-
-  describe '#find_definition' do
-    subject { described_class }
-
-    let(:method) { :get }
-    let(:status) { 200 }
-
-    before { allow(subject).to receive(:method).and_return(method) }
-
-    describe 'no response for status' do
-      let(:path) { { get: { responses: {} } } }
-
-      specify do
-        definition = subject.find_definition(status, path)
-        expect(definition).to be_nil
-      end
-    end
-
-    describe 'response found' do
-      let(:model) { 'Item' }
-
-      describe 'ref given' do
-        let(:path) do
-          { get: { responses: { 200 => { schema: { '$ref' => "#/definitions/#{model}" } } } } }
-        end
-        specify do
-          definition = subject.find_definition(status, path)
-          expect(definition).to eql model
-        end
-      end
-
-      describe 'items given' do
-        let(:path) do
-          { get: { responses: { 200 => { schema: { 'items' => { '$ref' => "#/definitions/#{model}" } } } } } }
-        end
-        specify do
-          definition = subject.find_definition(status, path)
-          expect(definition).to eql model
-        end
-      end
-    end
-  end
-
-  describe '#extended? and extension' do
-    subject { described_class }
-    describe 'return false (default)' do
-      let(:part) { { foo: 'bar', bar: 'foo' } }
-
-      specify do
-        expect(subject.extended?(part)).to be false
-        expect(subject.extension(part)).to be_empty
-      end
-    end
-
-    describe 'return true' do
-      specify do
-        part = { foo: 'bar', bar: 'foo', x: 'something' }
-        expect(subject.extended?(part)).to be true
-        expect(subject.extension(part)).to eql(x: 'something')
-        expect(subject.extended?(part, :x)).to be true
-        expect(subject.extension(part, :x)).to eql(x: 'something')
-      end
-
-      specify do
-        part = { foo: 'bar', bar: 'foo', x_path: 'something' }
-        expect(subject.extended?(part, :x_path)).to be true
-        expect(subject.extension(part, :x_path)).to eql(x_path: 'something')
-      end
-
-      specify do
-        part = { foo: 'bar', bar: 'foo', x_def: 'something' }
-        expect(subject.extended?(part, :x_def)).to be true
-        expect(subject.extension(part, :x_def)).to eql(x_def: 'something')
-      end
-
-      specify do
-        part = { foo: 'bar', bar: 'foo', x_path: 'something', x_def: 'something' }
-        expect(subject.extended?(part, :x_path)).to be true
-        expect(subject.extension(part, :x_path)).to eql(x_path: 'something')
-        expect(subject.extended?(part, :x_def)).to be true
-        expect(subject.extension(part, :x_def)).to eql(x_def: 'something')
-      end
-    end
-  end
-
-  describe 'concatenate' do
-    describe 'not nested' do
-      describe 'simple' do
-        let(:extensions) { { x: { key_1: 'foo' } } }
-        let(:result) { { 'x-key_1' => 'foo' } }
-        subject { described_class.concatenate(extensions) }
-
-        specify do
-          expect(subject).to eql result
-        end
-      end
-
-      describe 'multiple' do
-        let(:extensions) { { x: { key_1: 'foo', key_2: 'bar' } } }
-        let(:result) { { 'x-key_1' => 'foo', 'x-key_2' => 'bar' } }
-        subject { described_class.concatenate(extensions) }
-
-        specify do
-          expect(subject).to eql result
-        end
-      end
-    end
-
-    describe 'nested' do
-      describe 'simple' do
-        let(:extensions) { { x: { key_1: { key_2: 'foo' } } } }
-        let(:result) { { 'x-key_1' => { key_2: 'foo' } } }
-        subject { described_class.concatenate(extensions) }
-
-        specify do
-          expect(subject).to eql result
-        end
-      end
-
-      describe 'simple multiple' do
-        let(:extensions) { { x: { key_1: { key_2: 'foo', key_3: 'bar' } } } }
-        let(:result) { { 'x-key_1' => { key_2: 'foo', key_3: 'bar' } } }
-        subject { described_class.concatenate(extensions) }
-
-        specify do
-          expect(subject).to eql result
-        end
-      end
-
-      describe 'simple deeper' do
-        let(:extensions) { { x: { key_1: { key_2: { key_3: 'foo' } } } } }
-        let(:result) { { 'x-key_1' => { key_2: { key_3: 'foo' } } } }
-        subject { described_class.concatenate(extensions) }
-
-        specify do
-          expect(subject).to eql result
-        end
-      end
-
-      describe 'multiple' do
-        let(:extensions) { { x: { key_1: { key_3: 'foo' }, key_2: { key_3: 'bar' } } } }
-        let(:result) { { 'x-key_1' => { key_3: 'foo' }, 'x-key_2' => { key_3: 'bar' } } }
-        subject { described_class.concatenate(extensions) }
-
-        specify do
-          expect(subject).to eql result
-        end
-      end
-    end
-
-    describe 'real example' do
-      let(:extensions) do
-        { x: {
-          'amazon-apigateway-auth' => { type: 'none' },
-          'amazon-apigateway-integration' => { type: 'aws', uri: 'foo_bar_uri', httpMethod: 'get' }
-        } }
-      end
-      let(:result) do
-        {
-          'x-amazon-apigateway-auth' => { type: 'none' },
-          'x-amazon-apigateway-integration' => { type: 'aws', uri: 'foo_bar_uri', httpMethod: 'get' }
-        }
-      end
-      subject { described_class.concatenate(extensions) }
-
-      specify do
-        expect(subject).to eql result
-      end
-    end
-  end
-end

data/spec/lib/format_data_spec.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe GrapeSwagger::DocMethods::FormatData do
-  let(:subject) { GrapeSwagger::DocMethods::FormatData }
-
-  [true, false].each do |array_use_braces|
-    context 'when param is nested in a param of array type' do
-      let(:braces) { array_use_braces ? '[]' : '' }
-      let(:params) do
-        [
-          { in: 'formData', name: "param1#{braces}", type: 'array', items: { type: 'string' } },
-          { in: 'formData', name: 'param1[param2]', type: 'string' }
-        ]
-      end
-
-      it 'skips root parameter' do
-        expect(subject.to_format(params).first).not_to have_key "param1#{braces}"
-      end
-
-      it 'Move array type to param2' do
-        expect(subject.to_format(params).first).to include(name: "param1#{braces}[param2]", type: 'array')
-      end
-    end
-  end
-
-  context 'when param is nested in a param of hash type' do
-    let(:params) { [{ in: 'formData', type: 'object', name: 'param1' }, { in: 'formData', name: 'param1[param2]', type: 'string' }] }
-
-    it 'skips root parameter' do
-      expect(subject.to_format(params).first).not_to have_key 'param1'
-    end
-
-    it 'Move array type to param2' do
-      expect(subject.to_format(params).first).to include(name: 'param1[param2]', type: 'string')
-    end
-  end
-
-  context 'when params contain a complex array' do
-    let(:params) do
-      [
-        { name: 'id', required: true, type: 'string' },
-        { name: 'description', required: false, type: 'string' },
-        { name: 'stuffs', required: true, type: 'array' },
-        { name: 'stuffs[id]', required: true, type: 'string' }
-      ]
-    end
-
-    let(:expected_params) do
-      [
-        { name: 'id', required: true, type: 'string' },
-        { name: 'description', required: false, type: 'string' },
-        { name: 'stuffs[id]', required: true, type: 'array', items: { type: 'string' } }
-      ]
-    end
-
-    it 'parses params correctly and adds array type all concerned elements' do
-      expect(subject.to_format(params)).to eq expected_params
-    end
-
-    context 'when array params are not contiguous with parent array' do
-      let(:params) do
-        [
-          { name: 'id', required: true, type: 'string' },
-          { name: 'description', required: false, type: 'string' },
-          { name: 'stuffs', required: true, type: 'array' },
-          { name: 'stuffs[owners]', required: true, type: 'array' },
-          { name: 'stuffs[creators]', required: true, type: 'array' },
-          { name: 'stuffs[owners][id]', required: true, type: 'string' },
-          { name: 'stuffs[creators][id]', required: true, type: 'string' },
-          { name: 'stuffs_and_things', required: true, type: 'string' }
-        ]
-      end
-
-      let(:expected_params) do
-        [
-          { name: 'id', required: true, type: 'string' },
-          { name: 'description', required: false, type: 'string' },
-          { name: 'stuffs[owners][id]', required: true, type: 'array', items: { type: 'string' } },
-          { name: 'stuffs[creators][id]', required: true, type: 'array', items: { type: 'string' } },
-          { name: 'stuffs_and_things', required: true, type: 'string' }
-        ]
-      end
-
-      it 'parses params correctly and adds array type all concerned elements' do
-        expect(subject.to_format(params)).to eq expected_params
-      end
-    end
-
-    context 'when array params are not related' do
-      let(:params) do
-        [
-          { name: 'id', required: true, type: 'string' },
-          { name: 'description', required: false, type: 'string' },
-          { name: 'ids[]', required: true, type: 'array', items: { type: 'string' } },
-          { name: 'user_ids[]', required: true, type: 'array', items: { type: 'string' } }
-        ]
-      end
-
-      let(:expected_params) do
-        [
-          { name: 'id', required: true, type: 'string' },
-          { name: 'description', required: false, type: 'string' },
-          { name: 'ids[]', required: true, type: 'array', items: { type: 'string' } },
-          { name: 'user_ids[]', required: true, type: 'array', items: { type: 'string' } }
-        ]
-      end
-
-      it 'parses params correctly and adds array type all concerned elements' do
-        expect(subject.to_format(params)).to eq expected_params
-      end
-    end
-  end
-end

data/spec/lib/model_parsers_spec.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe GrapeSwagger::ModelParsers do
-  let(:model_parsers) { described_class.new }
-  let(:parser) { Class.new }
-  let(:parser2) { Class.new }
-  let(:parser3) { Class.new }
-
-  describe '#register' do
-    describe 'successfully register new parser' do
-      before do
-        model_parsers.register(parser, Class)
-      end
-
-      specify do
-        expect(model_parsers.to_a).to eq([[parser, 'Class']])
-      end
-    end
-
-    describe 'should be empty if no registered parsers' do
-      specify do
-        expect(model_parsers.to_a).to be_empty
-      end
-    end
-  end
-
-  describe '#insert_before' do
-    describe 'SomeModelParser2 should be first parser' do
-      before do
-        model_parsers.register(parser, Class)
-        model_parsers.register(parser3, Class)
-        model_parsers.insert_before(parser, parser2, Class)
-      end
-
-      specify do
-        expect(model_parsers.count).to eq(3)
-        expect(model_parsers.to_a.first).to eq([parser2, Class])
-      end
-    end
-
-    describe 'SomeModelParser2 should be inserted anyway if SomeModelParser not registered' do
-      before do
-        model_parsers.register(parser3, Class)
-        model_parsers.insert_before(parser, parser2, Class)
-      end
-
-      specify do
-        expect(model_parsers.count).to eq(2)
-        expect(model_parsers.to_a).to include([parser2, Class])
-      end
-    end
-
-    describe 'SomeModelParser2 should be inserted anyway if model parsers is empty' do
-      before do
-        model_parsers.insert_before(parser, parser2, Class)
-      end
-
-      specify do
-        expect(model_parsers.count).to eq(1)
-        expect(model_parsers.to_a).to include([parser2, Class])
-      end
-    end
-  end
-
-  describe '#insert_after' do
-    describe 'SomeModelParser2 should be second parser' do
-      before do
-        model_parsers.register(parser, Class)
-        model_parsers.register(parser3, Class)
-        model_parsers.insert_after(parser, parser2, Class)
-      end
-
-      specify do
-        expect(model_parsers.count).to eq(3)
-        expect(model_parsers.to_a[1]).to eq([parser2, Class])
-      end
-    end
-
-    describe 'SomeModelParser2 should be inserted anyway if SomeModelParser not registered' do
-      before do
-        model_parsers.register(parser3, Class)
-        model_parsers.insert_after(parser, parser2, Class)
-      end
-
-      specify do
-        expect(model_parsers.count).to eq(2)
-        expect(model_parsers.to_a).to include([parser2, Class])
-      end
-    end
-
-    describe 'SomeModelParser2 should be inserted anyway if model parsers is empty' do
-      before do
-        model_parsers.insert_after(parser, parser2, Class)
-      end
-
-      specify do
-        expect(model_parsers.count).to eq(1)
-        expect(model_parsers.to_a).to include([parser2, Class])
-      end
-    end
-  end
-end