brainstem 1.4.1 → 2.0.0

data/spec/brainstem/api_docs/formatters/open_api_specification/version_2/security_definitions_formatter_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+require 'brainstem/api_docs/formatters/open_api_specification/version_2/security_definitions_formatter'
+
+module Brainstem
+  module ApiDocs
+    module Formatters
+      module OpenApiSpecification
+        module Version2
+          describe SecurityDefinitionsFormatter do
+            subject { described_class.new }
+
+            describe 'call' do
+              before do
+                mock.proxy(subject).format_basic_auth_definitions!
+                mock.proxy(subject).format_apikey_auth_definitions!
+                mock.proxy(subject).format_oauth_definitions!
+                mock.proxy(subject).format_security_object!
+              end
+
+              it 'includes security definitions' do
+                output = subject.call
+              end
+            end
+
+            describe 'format_basic_auth_definitions!' do
+              context 'when definition exists' do
+                let(:basic_auth_definition) { { 'basic' => { 'type' => 'basic' } } }
+
+                before do
+                  mock(subject).basic_auth_definitions { basic_auth_definition }
+                end
+
+                it 'includes the correct attributes' do
+                  subject.send(:format_basic_auth_definitions!)
+
+                  expect(subject.output.keys).to match_array(%w(securityDefinitions))
+                  expect(subject.output['securityDefinitions']).to eq(basic_auth_definition)
+                end
+              end
+
+              context 'when definition is blank' do
+                before do
+                  mock.proxy(subject).basic_auth_definitions
+                end
+
+                it 'does not add securityDefinitions key' do
+                  subject.send(:format_basic_auth_definitions!)
+
+                  expect(subject.output).to be_empty
+                end
+              end
+            end
+
+            describe 'format_apikey_auth_definitions!' do
+              context 'when definition exists' do
+                before do
+                  mock.proxy(subject).apikey_auth_definitions
+                end
+
+                it 'includes the correct attributes' do
+                  subject.send(:format_apikey_auth_definitions!)
+
+                  expect(subject.output.keys).to match_array(%w(securityDefinitions))
+                  expect(subject.output['securityDefinitions']).to eq({
+                    'api_key' => {
+                      'type' => 'apiKey',
+                      'name' => 'api_key',
+                      'in'   => 'header'
+                    }
+                  })
+                end
+              end
+
+              context 'when definition is blank' do
+                before do
+                  mock(subject).apikey_auth_definitions { {} }
+                end
+
+                it 'does not add securityDefinitions key' do
+                  subject.send(:format_apikey_auth_definitions!)
+
+                  expect(subject.output).to be_empty
+                end
+              end
+            end
+
+            describe 'format_apikey_auth_definitions!' do
+              context 'when definition exists' do
+                before do
+                  mock.proxy(subject).apikey_auth_definitions
+                end
+
+                it 'includes the correct attributes' do
+                  subject.send(:format_apikey_auth_definitions!)
+
+                  expect(subject.output.keys).to match_array(%w(securityDefinitions))
+                  expect(subject.output['securityDefinitions']).to eq({
+                    'api_key' => {
+                      'type' => 'apiKey',
+                      'name' => 'api_key',
+                      'in'   => 'header'
+                    }
+                  })
+                end
+              end
+
+              context 'when definition is blank' do
+                before do
+                  mock(subject).apikey_auth_definitions { {} }
+                end
+
+                it 'does not add securityDefinitions key' do
+                  subject.send(:format_apikey_auth_definitions!)
+
+                  expect(subject.output).to be_empty
+                end
+              end
+            end
+
+            describe 'format_oauth_definitions!' do
+              context 'when definition exists' do
+                before do
+                  mock.proxy(subject).oauth_definitions
+                end
+
+                it 'includes the correct attributes' do
+                  subject.send(:format_oauth_definitions!)
+
+                  expect(subject.output.keys).to match_array(%w(securityDefinitions))
+                  expect(subject.output['securityDefinitions']).to eq({
+                    'petstore_auth' => {
+                      'type'             => 'oauth2',
+                      'authorizationUrl' => 'http://petstore.swagger.io/oauth/dialog',
+                      'flow'             => 'implicit',
+                      'scopes'           => {
+                        'write:pets' => 'modify pets in your account',
+                        'read:pets'  => 'read your pets'
+                      }
+                    }
+                  })
+                end
+              end
+
+              context 'when definition is blank' do
+                before do
+                  mock(subject).oauth_definitions { {} }
+                end
+
+                it 'does not add securityDefinitions key' do
+                  subject.send(:format_oauth_definitions!)
+
+                  expect(subject.output).to be_empty
+                end
+              end
+            end
+
+            describe 'format_security_object!' do
+              context 'when definition exists' do
+                let(:security_object) { { 'petstore_auth' => ['write:pets', 'read:pets'] } }
+
+                before do
+                  mock(subject).security_object { security_object }.times(2)
+                end
+
+                it 'includes the correct attributes' do
+                  subject.send(:format_security_object!)
+
+                  expect(subject.output.keys).to match_array(%w(security))
+                  expect(subject.output['security']).to eq(security_object)
+                end
+              end
+
+              context 'when definition is blank' do
+                before do
+                  mock.proxy(subject).security_object
+                end
+
+                it 'does not add security key' do
+                  subject.send(:format_security_object!)
+
+                  expect(subject.output).to be_empty
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/brainstem/api_docs/formatters/open_api_specification/version_2/tags_formatter_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+require 'brainstem/api_docs/formatters/open_api_specification/version_2/tags_formatter'
+require 'brainstem/api_docs/controller'
+
+module Brainstem
+  module ApiDocs
+    module Formatters
+      module OpenApiSpecification
+        module Version2
+          describe TagsFormatter do
+            let(:atlas)        { Object.new }
+            let(:documentable_controller_Z) {
+              OpenStruct.new(
+                name:        'controller_Z',
+                description: 'controller_Z desc',
+                endpoints:   OpenStruct.new(only_documentable: [1, 2]),
+                tag:         'Tag Z',
+                tag_groups:  ['Group Z'],
+              )
+            }
+            let(:documentable_controller_A) {
+              OpenStruct.new(
+                name:        'controller_A',
+                description: 'controller_A desc',
+                endpoints:   OpenStruct.new(only_documentable: [1, 2]),
+                tag:         'Tag A',
+                tag_groups:  ['Group Z', 'Group A'],
+              )
+            }
+            let(:nodoc_controller) {
+              OpenStruct.new(
+                name:        'controller_nodoc',
+                description: 'controller_nodoc desc',
+                endpoints:   OpenStruct.new(only_documentable: [1, 2]),
+                tag:         'No Doc',
+                tag_groups:  ['No Doc Group'],
+              )
+            }
+            let(:no_endpoint_controller) {
+              OpenStruct.new(
+                name:        'controller_no_endpoint',
+                description: 'controller_no_endpoint desc',
+                endpoints:   OpenStruct.new(only_documentable: []),
+                tag:         'No Endpoint',
+                tag_groups:  ['No Endpoint Group'],
+              )
+            }
+            let(:no_tag_controller) {
+              OpenStruct.new(
+                name:        'no_tag_controller',
+                description: 'no_tag_controller desc',
+                endpoints:   OpenStruct.new(only_documentable: [1])
+              )
+            }
+            let(:controllers) {
+              [
+                documentable_controller_Z,
+                documentable_controller_A,
+                nodoc_controller,
+                no_endpoint_controller,
+                no_tag_controller
+              ]
+            }
+            let(:ignore_tagging) { false }
+            let(:options)        { { ignore_tagging: ignore_tagging } }
+
+            def extract_tag_names(tags)
+              tags.map { |tag| tag['name'] }
+            end
+
+            subject { described_class.new(controllers, options) }
+
+            before do
+              stub(nodoc_controller).nodoc? { true }
+            end
+
+            describe 'call' do
+              describe 'when ignore tags option is selected' do
+                let(:ignore_tagging) { true }
+
+                before do
+                  dont_allow(subject).format_tags!
+                  dont_allow(subject).format_tag_groups!
+                end
+
+                it 'returns empty object' do
+                  expect(subject.call).to be_empty
+                end
+              end
+
+              describe 'when no controllers are passed in' do
+                let(:controllers) { [] }
+
+                before do
+                  dont_allow(subject).format_tags!
+                  dont_allow(subject).format_tag_groups!
+                end
+
+                it 'returns empty object' do
+                  expect(subject.call).to be_empty
+                end
+              end
+
+              describe 'when controllers are present and ignore tags is false' do
+                before do
+                  mock(subject).format_tags!
+                  mock(subject).format_tag_groups!
+                end
+
+                it 'includes tag definitions' do
+                  subject.call
+                end
+              end
+            end
+
+            describe '#format_tags!' do
+              it 'excludes no doc controllers' do
+                subject.send(:format_tags!)
+
+                expect(subject.output).to have_key('tags')
+                expect(extract_tag_names(subject.output['tags'])).to_not include('No Doc')
+              end
+
+              it 'excludes controllers with no documentable endpoints' do
+                subject.send(:format_tags!)
+
+                expect(subject.output).to have_key('tags')
+                expect(extract_tag_names(subject.output['tags'])).to_not include('No Endpoint')
+              end
+
+              it 'returns a array of tags sorted by name of the tag' do
+                subject.send(:format_tags!)
+
+                expect(subject.output).to have_key('tags')
+                expect(subject.output['tags']).to eq([
+                  {
+                    'name' => 'No Tag Controller',
+                    'description' => 'No_tag_controller desc.'
+                  },
+                  {
+                    'name' => 'Tag A',
+                    'description' => 'Controller_A desc.'
+                  },
+                  {
+                    'name' => 'Tag Z',
+                    'description' => 'Controller_Z desc.'
+                  },
+                ])
+              end
+            end
+
+            describe '#format_tag_groups!!' do
+              it 'excludes no doc controllers' do
+                subject.send(:format_tag_groups!)
+
+                expect(subject.output).to have_key('x-tagGroups')
+                expect(extract_tag_names(subject.output['x-tagGroups'])).to_not include('No Doc Group')
+              end
+
+              it 'excludes controllers with no documentable endpoints' do
+                subject.send(:format_tag_groups!)
+
+                expect(subject.output).to have_key('x-tagGroups')
+                expect(extract_tag_names(subject.output['x-tagGroups'])).to_not include('No Endpoint Group')
+              end
+
+              it 'returns a array of tag groups sorted by name of the group name' do
+                subject.send(:format_tag_groups!)
+
+                expect(subject.output).to have_key('x-tagGroups')
+                expect(subject.output['x-tagGroups']).to eq([
+                  {
+                    'name' => 'Group A',
+                    'tags' => ['Tag A']
+                  },
+                  {
+                    'name' => 'Group Z',
+                    'tags' => ['Tag A', 'Tag Z']
+                  },
+                  {
+                    'name' => 'No Tag Controller',
+                    'tags' => ['No Tag Controller']
+                  },
+                ])
+              end
+
+              context 'when none of the controllers have tag groups specified' do
+                let(:documentable_controller_Z) {
+                  OpenStruct.new(
+                    name:        'controller_Z',
+                    description: 'controller_Z desc',
+                    endpoints:   OpenStruct.new(only_documentable: [1, 2]),
+                    tag:         'Tag Z',
+                  )
+                }
+                let(:documentable_controller_A) {
+                  OpenStruct.new(
+                    name:        'controller_A',
+                    description: 'controller_A desc',
+                    endpoints:   OpenStruct.new(only_documentable: [1, 2]),
+                    tag:         'Tag A',
+                  )
+                }
+
+                it 'does not add tag groups to the output' do
+                  subject.send(:format_tag_groups!)
+
+                  expect(subject.output).to_not have_key('x-tagGroups')
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/brainstem/api_docs/introspectors/abstract_introspector_spec.rb

@@ -43,7 +43,6 @@ module Brainstem
           end
         end
 
-
         describe "#load_environment!" do
           it "is not implemented" do
             expect { subject.send(:load_environment!) }.to raise_error NotImplementedError
@@ -131,7 +130,6 @@ module Brainstem
           end
         end
 
-
         describe "#valid_presenters?" do
           it "is valid when a collection of zero or more classes" do
             stub(subject).presenters { [ Integer ] }

data/spec/brainstem/api_docs/introspectors/rails_introspector_spec.rb

@@ -81,7 +81,6 @@ module Brainstem
               )
             end
 
-
             it "allows the specification of a custom base_presenter_class" do
               expect(subject.send(:base_presenter_class).to_s)
                 .to eq "::FakeBasePresenter"
@@ -103,7 +102,6 @@ module Brainstem
               )
             end
 
-
             it "allows the specification of a custom base_controller_class" do
               expect(subject.send(:base_controller_class).to_s)
                 .to eq "::FakeBaseController"

data/spec/brainstem/api_docs/presenter_collection_spec.rb

@@ -33,7 +33,6 @@ module Brainstem
         end
       end
 
-
       describe "#create_from_target_class" do
         let(:pclm) { Object.new }
         let(:options) { { presenter_constant_lookup_method: pclm } }
@@ -66,7 +65,6 @@ module Brainstem
         end
       end
 
-
       describe "#create_from_presenter_collection" do
         let(:const) { Class.new }