gitlab-grape-swagger 1.5.0

data/spec/lib/extensions_spec.rb

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

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

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