grape-swagger 0.11.0 → 0.20.0

data/spec/lib/endpoint_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe Grape::Endpoint do
+  subject { described_class.new(Grape::Util::InheritableSetting.new, {path: '/', method: :get}) }
+
+end

data/spec/lib/extensions_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe GrapeSwagger::DocMethods::Extensions do
+  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 "reale example" do
+      let(:extensions) { {x: {
+        'amazon-apigateway-auth' => {type: 'none'},
+        'amazon-apigateway-integration' => {type: 'aws', uri: 'foo_bar_uri', httpMethod: 'get'}
+      }} }
+      let(:result) { {
+        'x-amazon-apigateway-auth' => {type: 'none'},
+        'x-amazon-apigateway-integration' => {type: 'aws', uri: 'foo_bar_uri', httpMethod: 'get'}
+      } }
+      subject { described_class.concatenate(extensions) }
+
+      specify do
+        expect(subject).to eql result
+      end
+    end
+  end
+end

data/spec/lib/move_params_spec.rb

@@ -0,0 +1,298 @@
+require 'spec_helper'
+
+describe GrapeSwagger::DocMethods::MoveParams do
+  include_context "the api paths/defs"
+
+  subject { described_class }
+
+  it { expect(subject.to_s).to eql 'GrapeSwagger::DocMethods::MoveParams' }
+
+  describe 'find_post_put' do
+    let(:paths) { {} }
+
+    describe 'paths empty' do
+      specify { expect { |b| subject.find_post_put(paths, &b) }.not_to yield_control }
+    end
+
+    describe 'no post/put given' do
+      let(:paths) {{
+        :'/foo'=> { get: {}, delete: {}},
+        :'/bar/{key}'=> { get: {}, delete: {}},
+      }}
+      specify { expect { |b| subject.find_post_put(paths, &b) }.not_to yield_control }
+    end
+
+    describe 'no post/put given' do
+      let(:paths) {{
+        :'/foo'=> { get: {}, delete: {}, post: {}, put: {}, patch: {} },
+        :'/bar/{key}'=> { get: {}, delete: {}, post: {}, put: {}, patch: {}},
+      }}
+      let(:expected) {[
+        { post: {}, put: {}, patch: {}},
+        { post: {}, put: {}, patch: {}},
+      ]}
+      specify { expect { |b| subject.find_post_put(paths, &b) }.to yield_control.twice }
+      specify { expect { |b| subject.find_post_put(paths, &b) }.to yield_successive_args *expected }
+    end
+  end
+
+  describe 'find_definition_and_params' do
+    specify do
+      subject.instance_variable_set(:@definitions, definitions)
+      subject.find_definition_and_params(found_path)
+
+      expect(definitions.keys).to include 'InBody', 'postRequestInBody'
+    end
+  end
+
+  describe 'move_params_to_new definition' do
+    let(:name) { 'Foo' }
+    let(:definitions) {{}}
+
+    describe 'post request' do
+      let(:verb) { 'post' }
+      let(:params) { paths["/in_body"][:post][:parameters] }
+
+      specify do
+        subject.instance_variable_set(:@definitions, definitions)
+        name = subject.send(:build_definition, name, verb)
+        subject.move_params_to_new(name, params)
+
+        expect(definitions[name]).to eql expected_post_defs
+        expect(params).to be_empty
+      end
+    end
+
+    describe 'put request' do
+      let(:verb) { 'put' }
+      let(:params) { paths["/in_body/{key}"][:put][:parameters] }
+
+      specify do
+        subject.instance_variable_set(:@definitions, definitions)
+        name, definition = subject.send(:build_definition, name, verb)
+        subject.move_params_to_new(name, params)
+
+        expect(definitions[name]).to eql expected_put_defs
+        expect(params.length).to be 1
+      end
+    end
+  end
+
+  describe 'nested definitions related' do
+    describe 'prepare_nested_names' do
+      before do
+        subject.send(:prepare_nested_names, params)
+      end
+
+      describe 'simple' do
+        let(:params) {[{:in=>"body", :name=>"address[street]", :description=>"street", :type=>"string", :required=>true}]}
+        let(:expected) {[{:in=>"body", :name=>"street", :description=>"street", :type=>"string", :required=>true}]}
+        specify do
+          expect(params).to eql expected
+        end
+      end
+
+      describe 'nested' do
+        let(:params) {[{:in=>"body", :name=>"address[street][name]", :description=>"street", :type=>"string", :required=>true}]}
+        let(:expected) {[{:in=>"body", :name=>"street[name]", :description=>"street", :type=>"string", :required=>true}]}
+        specify do
+          expect(params).to eql expected
+        end
+      end
+
+      describe 'array' do
+        let(:params) {[{:in=>"body", :name=>"address[][street_lines]", :description=>"street lines", :type=>"array", :required=>true}]}
+        let(:expected) {[{:in=>"body", :name=>"street_lines", :description=>"street lines", :type=>"array", :required=>true}]}
+        specify do
+          expect(params).to eql expected
+        end
+      end
+    end
+  end
+
+  describe 'private methods' do
+    describe 'build_definition' do
+      before do
+        subject.instance_variable_set(:@definitions, definitions)
+        subject.send(:build_definition, name, verb)
+      end
+
+      describe 'verb given' do
+        let(:verb) { 'post' }
+        let(:name) { 'Foo' }
+        let(:definitions) {{}}
+
+        specify do
+          definition = definitions.to_a.first
+          expect(definition.first).to eql 'postRequestFoo'
+          expect(definition.last).to eql({ type: 'object', properties: {}, required: [] })
+        end
+      end
+
+      describe 'no verb given' do
+        let(:name) { 'FooBar' }
+        let(:definitions) {{}}
+        let(:verb) { nil }
+
+        specify do
+          definition = definitions.to_a.first
+          expect(definition.first).to eql 'FooBar'
+          expect(definition.last).to eql({ type: 'object', properties: {}, required: [] })
+        end
+      end
+    end
+
+    describe 'build_body_parameter' do
+      let(:response) {{ schema: { '$ref' => '#/definitions/Somewhere'} }}
+
+      describe 'no name given' do
+        let(:name) { nil }
+        let(:expected_param) {
+          {:name=>"Somewhere", :in=>"body", :required=>true, :schema=>{'$ref' => "#/definitions/Somewhere"}}
+        }
+        specify do
+          parameter = subject.send(:build_body_parameter, response)
+          expect(parameter).to eql expected_param
+        end
+      end
+
+      describe 'name given' do
+        let(:name) { 'Foo' }
+        let(:expected_param) {
+          {:name=>"Somewhere", :in=>"body", :required=>true, :schema=>{'$ref' => "#/definitions/#{name}"}}
+        }
+        specify do
+          parameter = subject.send(:build_body_parameter, response, name)
+          expect(parameter).to eql expected_param
+        end
+      end
+    end
+
+    describe 'parse_model' do
+      let(:ref) { '#/definitions/InBody' }
+      subject(:object) { described_class.send(:parse_model, ref) }
+
+      specify { expect(object).to eql 'InBody' }
+    end
+
+    describe 'movable' do
+      describe 'path' do
+        let(:param) {{ in: "path", name: "key", description: nil, type: "integer", format: "int32", required: true }}
+        it { expect(subject.send(:movable?, param)).to be true }
+      end
+
+      describe 'body' do
+        let(:param) {{ in: "body", name: "in_body", description: "in_body", type: "integer", format: "int32", required: true }}
+        it { expect(subject.send(:movable?, param)).to be true }
+      end
+
+      describe 'query' do
+        let(:param) {{ in: "query", name: "in_query", description: "in_query", type: "integer", format: "int32", required: true }}
+        it { expect(subject.send(:movable?, param)).to be false }
+      end
+
+      describe 'header' do
+        let(:param) {{ in: "header", name: "in_header", description: "in_header", type: "integer", format: "int32", required: true }}
+        it { expect(subject.send(:movable?, param)).to be false }
+      end
+    end
+
+    describe 'deletable' do
+      describe 'path' do
+        let(:param) {{ in: "path", name: "key", description: nil, type: "integer", format: "int32", required: true }}
+        it { expect(subject.send(:deletable?, param)).to be false }
+      end
+
+      describe 'body' do
+        let(:param) {{ in: "body", name: "in_body_1", description: "in_body_1", type: "integer", format: "int32", required: true }}
+        it { expect(subject.send(:deletable?, param)).to be true }
+      end
+
+      describe 'query' do
+        let(:param) {{ in: "query", name: "in_query_1", description: "in_query_1", type: "integer", format: "int32", required: true }}
+        it { expect(subject.send(:deletable?, param)).to be false }
+      end
+
+      describe 'header' do
+        let(:param) {{ in: "header", name: "in_header_1", description: "in_header_1", type: "integer", format: "int32", required: true }}
+        it { expect(subject.send(:deletable?, param)).to be false }
+      end
+    end
+
+    describe 'should move' do
+      describe 'no move' do
+        let(:params) {[
+          { in: "path", name: "key", description: nil, type: "integer", format: "int32", required: true },
+          { in: "formData", name: "in_form_data", description: "in_form_data", type: "integer", format: "int32", required: true }
+        ]}
+        it { expect(subject.send(:should_move?, params)).to be false }
+      end
+
+      describe 'move' do
+        let(:params) {[
+          { in: "path", name: "key", description: nil, type: "integer", format: "int32", required: true },
+          { in: "body", name: "in_bosy", description: "in_bosy", type: "integer", format: "int32", required: true },
+          { in: "formData", name: "in_form_data", description: "in_form_data", type: "integer", format: "int32", required: true }
+        ]}
+        it { expect(subject.send(:should_move?, params)).to be true }
+      end
+    end
+
+    describe 'unify' do
+      before do
+        subject.send(:unify!, params) if subject.send(:should_move?, params)
+      end
+      describe 'param type with `:in` given' do
+        let(:params) {[
+          { in: "path", name: "key", description: nil, type: "integer", format: "int32", required: true },
+          { in: "body", name: "in_body", description: "in_body", type: "integer", format: "int32", required: true },
+          { in: "query", name: "in_query", description: "in_query", type: "integer", format: "int32", required: true },
+          { in: "header", name: "in_header", description: "in_header", type: "integer", format: "int32", required: true },
+          { in: "formData", name: "in_form_data", description: "in_form_data", type: "integer", format: "int32", required: true }
+        ]}
+
+        let(:expected_params) {[
+          { in: "path", name: "key", description: nil, type: "integer", format: "int32", required: true },
+          { in: "body", name: "in_body", description: "in_body", type: "integer", format: "int32", required: true },
+          { in: "query", name: "in_query", description: "in_query", type: "integer", format: "int32", required: true },
+          { in: "header", name: "in_header", description: "in_header", type: "integer", format: "int32", required: true },
+          { in: "body", name: "in_form_data", description: "in_form_data", type: "integer", format: "int32", required: true }
+        ]}
+        it { expect(params).to eql expected_params }
+      end
+
+      describe 'let it as is' do
+        let(:params) {[
+          { in: "path", name: "key", description: nil, type: "integer", format: "int32", required: true },
+          { in: "formData", name: "in_form_data", description: "in_form_data", type: "integer", format: "int32", required: true }
+        ]}
+
+        let(:expected_params) {[
+          { in: "path", name: "key", description: nil, type: "integer", format: "int32", required: true },
+          { in: "formData", name: "in_form_data", description: "in_form_data", type: "integer", format: "int32", required: true }
+        ]}
+        it { expect(params).to eql expected_params }
+
+      end
+
+      describe 'param type with `:param_type` given' do
+        let(:params) {[
+          { param_type: "path", name: "key", description: nil, type: "integer", format: "int32", required: true },
+          { param_type: "body", name: "in_body", description: "in_body", type: "integer", format: "int32", required: true },
+          { param_type: "query", name: "in_query", description: "in_query", type: "integer", format: "int32", required: true },
+          { param_type: "header", name: "in_header", description: "in_header", type: "integer", format: "int32", required: true },
+          { param_type: "formData", name: "in_form_data", description: "in_form_data", type: "integer", format: "int32", required: true }
+        ]}
+
+        let(:expected_params) {[
+          { name: "key", description: nil, type: "integer", format: "int32", required: true, in: "path" },
+          { name: "in_body", description: "in_body", type: "integer", format: "int32", required: true, in: "body" },
+          { name: "in_query", description: "in_query", type: "integer", format: "int32", required: true, in: "query" },
+          { name: "in_header", description: "in_header", type: "integer", format: "int32", required: true, in: "header" },
+          { name: "in_form_data", description: "in_form_data", type: "integer", format: "int32", required: true, in: "body" }
+        ]}
+        it { expect(params).to eql expected_params }
+      end
+    end
+  end
+end

data/spec/lib/operation_id_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe GrapeSwagger::DocMethods::OperationId do
+  subject { described_class }
+
+  specify { expect(subject).to eql GrapeSwagger::DocMethods::OperationId }
+  specify { expect(subject).to respond_to :build }
+
+  describe 'build' do
+    specify do
+      expect(subject.build('GET')).to eql 'get'
+      expect(subject.build('get')).to eql 'get'
+      expect(subject.build(:get)).to eql 'get'
+      expect(subject.build('GET', 'foo')).to eql 'getFoo'
+      expect(subject.build('GET', '/foo')).to eql 'getFoo'
+      expect(subject.build('GET', 'bar/foo')).to eql 'getBarFoo'
+      expect(subject.build('GET', 'bar/foo{id}')).to eql 'getBarFooId'
+      expect(subject.build('GET', '/bar_foo{id}')).to eql 'getBarFooId'
+      expect(subject.build('GET', '/bar-foo{id}')).to eql 'getBarFooId'
+      expect(subject.build('GET', '/simple_test/bar-foo{id}')).to eql 'getSimpleTestBarFooId'
+    end
+  end
+
+end