apipie-rails 0.5.19 → 1.3.0

data/spec/lib/apipie/generator/swagger/method_description/api_schema_service_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::MethodDescription::ApiSchemaService do
+  let(:path) { '/api' }
+  let(:http_method) { 'get' }
+  let(:resource_id) { 'users' }
+  let(:method_description_description) { nil }
+  let(:tags) { [] }
+
+  let(:dsl_data) do
+    ActionController::Base
+      .send(:_apipie_dsl_data_init)
+      .merge(
+        {
+          description: method_description_description,
+          api_args: [[http_method, path, 'Some api description', { deprecated: true }]],
+          tag_list: tags
+        }
+      )
+  end
+
+  let(:resource_desc) do
+    Apipie::ResourceDescription.new(UsersController, resource_id)
+  end
+
+  let(:method_description) do
+    Apipie::Generator::Swagger::MethodDescription::Decorator.new(
+      Apipie::MethodDescription.new(:show, resource_desc, dsl_data)
+    )
+  end
+
+  let(:service) { described_class.new(method_description) }
+
+  describe '#call' do
+    subject(:schema) { service.call }
+
+    it 'returns the path' do
+      expect(schema).to include(path)
+    end
+
+    it 'returns the http method' do
+      expect(schema[path]).to include(http_method)
+    end
+
+    it 'returns the correct attributes' do
+      expect(schema[path][http_method].keys).to include(
+        :tags,
+        :consumes,
+        :operationId,
+        :parameters,
+        :responses
+      )
+    end
+  end
+
+  describe 'tags' do
+    subject { service.call[path][http_method][:tags] }
+
+    it { is_expected.to eq([resource_id]) }
+
+    context 'when tags are available' do
+      let(:tags) { ['Tag 1', 'Tag 2'] }
+
+      it { is_expected.to include(*tags) }
+    end
+
+    context 'when Apipie.configuration.generator.swagger.skip_default_tags is enabled' do
+      before { Apipie.configuration.generator.swagger.skip_default_tags = true }
+      after { Apipie.configuration.generator.swagger.skip_default_tags = false }
+
+      it { is_expected.to be_empty }
+
+      context 'when tags are available' do
+        let(:tags) { ['Tag 1', 'Tag 2'] }
+
+        it { is_expected.to eq(tags) }
+      end
+    end
+
+    context 'when Apipie.configuration.generator.swagger.include_warning_tags is enabled' do
+      before { Apipie.configuration.generator.swagger.include_warning_tags = true }
+
+      context 'when warnings are issued' do
+        before do
+          Apipie::Generator::Swagger::Warning.for_code(
+            Apipie::Generator::Swagger::Warning::MISSING_METHOD_SUMMARY_CODE,
+            'some_method'
+          ).warn_through_writer
+        end
+
+        it { is_expected.to include('warnings issued') }
+      end
+    end
+  end
+
+  describe 'consumes' do
+    subject { service.call[path]['get'][:consumes] }
+
+    it { is_expected.to eq(['application/x-www-form-urlencoded', 'multipart/form-data']) }
+
+    context 'when content type input is json' do
+      before { Apipie.configuration.generator.swagger.content_type_input = :json }
+
+      it { is_expected.to eq(['application/json']) }
+    end
+  end
+
+  describe 'description' do
+    subject { service.call[path]['get'][:description] }
+
+    it { is_expected.to be_blank }
+
+    context 'when description for method description exists' do
+      let(:method_description_description) { 'Some description' }
+
+      it { is_expected.to eq(method_description_description) }
+    end
+  end
+end

data/spec/lib/apipie/generator/swagger/method_description/response_schema_service_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::MethodDescription::ResponseSchemaService do
+  let(:http_method) { nil }
+  let(:controller_method) { nil }
+  let(:allow_null) { false }
+
+  let(:resource_description) do
+    Apipie::ResourceDescription.new(PetsController, 'pets')
+  end
+
+  let(:method_description) do
+    Apipie::MethodDescription.new(
+      'create',
+      resource_description,
+      ActionController::Base.send(:_apipie_dsl_data_init)
+    )
+  end
+
+  let(:response_description_dsl) do
+    proc do
+      property :a_number, Integer, example: 1
+      property :an_optional_number, Integer, required: false, example: 2
+    end
+  end
+
+  let(:options) { {} }
+
+  let(:response_description) do
+    Apipie::ResponseDescription.new(
+      method_description,
+      204,
+      options,
+      PetsController,
+      response_description_dsl,
+      nil
+    )
+  end
+
+  let(:service) do
+    described_class.new(
+      response_description,
+      allow_null: allow_null,
+      http_method: http_method,
+      controller_method: controller_method
+    )
+  end
+
+  describe '#to_swagger' do
+    let(:swagger_response) { service.to_swagger }
+
+    describe 'properties' do
+      subject(:properties) { swagger_response[:properties] }
+
+      it 'returns correct properties' do
+        expect(properties).to eq(
+          {
+            a_number: {
+              type: 'number', required: true, example: 1
+            },
+            an_optional_number: {
+              type: 'number', example: 2
+            }
+          }
+        )
+      end
+
+      context 'when nulls are allowed' do
+        let(:allow_null) { true }
+
+        it 'returns correct properties' do
+          expect(properties).to eq(
+            {
+              a_number: {
+                type: %w[number null], required: true, example: 1
+              },
+              an_optional_number: {
+                type: %w[number null], example: 2
+              }
+            }
+          )
+        end
+      end
+    end
+
+    context 'when responses_use_refs is set to true' do
+      subject(:response) { swagger_response }
+
+      before { Apipie.configuration.generator.swagger.responses_use_refs = true }
+      after { Apipie.configuration.generator.swagger.responses_use_refs = false }
+
+      context 'when typename is given' do
+        let(:options) { { param_group: :some_param_group } }
+
+        it 'returns the reference' do
+          expect(response).to eq(
+            {
+              '$ref' => '#/definitions/some_param_group'
+            }
+          )
+        end
+      end
+    end
+  end
+end

data/spec/lib/apipie/generator/swagger/operation_id_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::OperationId do
+  let(:path) { '/api' }
+  let(:http_method) { :GET }
+  let(:param) {}
+
+  let(:operation_id) do
+    described_class.new(path: path, http_method: http_method, param: param)
+  end
+
+  describe '#to_s' do
+    subject { operation_id.to_s}
+
+    it { is_expected.to eq('get_api') }
+
+    context 'when path has variable' do
+      let(:path) { '/api/users/:id' }
+
+      it { is_expected.to eq("#{http_method.downcase}_api_users_id") }
+    end
+
+    context 'when param is given' do
+      let(:param) { 'show' }
+
+      it { is_expected.to eq("#{http_method.downcase}_api_param_show") }
+    end
+  end
+
+  describe '.from' do
+    subject { described_class.from(describable).to_s }
+
+    context 'when an Apipie::MethodDescription::Api is given' do
+      let(:describable) do
+        Apipie::MethodDescription::Api.
+          new(http_method, path, '', { from_routes: '' })
+      end
+
+      it { is_expected.to eq("#{http_method.downcase}_api") }
+    end
+
+    context 'when an Apipie::MethodDescription is given' do
+      let(:dsl_data) do
+        ActionController::Base.
+          send(:_apipie_dsl_data_init).
+          merge({
+            api_args: [[http_method, path, "description", { :deprecated => true }]]
+          })
+      end
+
+      let(:resource_desc) do
+        Apipie::ResourceDescription.new(UsersController, "users")
+      end
+
+      let(:describable) do
+        Apipie::MethodDescription.new(:show, resource_desc, dsl_data)
+      end
+
+      it { is_expected.to eq("#{http_method.downcase}_api") }
+    end
+  end
+end
+

data/spec/lib/apipie/generator/swagger/param_description/builder_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::ParamDescription::Builder do
+  let(:validator) { String }
+  let(:validator_options) { {} }
+  let(:path) { '/api' }
+  let(:http_method) { :GET }
+  let(:in_schema) { true }
+  let(:builder) do
+    described_class.new(
+      param_description,
+      in_schema: in_schema,
+      controller_method: method_desc
+    )
+  end
+  let(:generated_block) { builder.to_swagger }
+  let(:base_param_description_options) { {} }
+
+  let(:param_description_options) do
+    base_param_description_options.merge(validator_options)
+  end
+
+  let(:base_dsl_data) do
+    {
+      :api => false,
+      :api_args => [],
+      :api_from_routes => nil,
+      :errors => [],
+      :tag_list => [],
+      :returns => {},
+      :params => [],
+      :headers => [],
+      :resource_id => nil,
+      :short_description => nil,
+      :description => nil,
+      :examples => [],
+      :see => [],
+      :formats => nil,
+      :api_versions => [],
+      :meta => nil,
+      :show => true,
+      :deprecated => false
+    }
+  end
+
+  let(:dsl_data) do
+    base_dsl_data.merge({
+      api_args: [
+        [
+          http_method,
+          path,
+          'description',
+          { deprecated: true }
+        ]
+      ]
+    })
+  end
+
+  let(:resource_desc) do
+    Apipie::ResourceDescription.new(UsersController, 'dummy')
+  end
+
+  let(:method_desc) do
+    Apipie::MethodDescription.new(:show, resource_desc, dsl_data)
+  end
+
+  let(:param_description) do
+    Apipie::ParamDescription.new(
+      method_desc,
+      :param,
+      validator,
+      param_description_options
+    )
+  end
+
+  describe 'required' do
+    subject { generated_block[:required] }
+
+    it { is_expected.to be_blank }
+
+    context 'when is required' do
+      let(:base_param_description_options) { { required: true } }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context 'when in_schema is false' do
+      let(:in_schema) { false }
+
+      it { is_expected.to be_blank }
+
+      context 'and is required' do
+        let(:base_param_description_options) { { required: true } }
+
+        it { is_expected.to eq(true) }
+      end
+    end
+  end
+
+  describe 'warning' do
+    before { Singleton.__init__(Apipie::Generator::Swagger::WarningWriter) }
+
+    subject { generated_block }
+
+    context 'when required is true' do
+      let(:base_param_description_options) { { required: true } }
+
+      it 'does not output an option without default warning' do
+        expect { subject }.not_to output(
+          /is optional but default value is not specified/
+        ).to_stderr
+      end
+    end
+
+    context 'when required is false' do
+      context 'when default_value is nil' do
+        let(:base_param_description_options) do
+          { required: false, default_value: nil }
+        end
+
+        it 'will not warn' do
+          expect { subject }.not_to output(
+            /is optional but default value is not specified/
+          ).to_stderr
+        end
+      end
+
+      context 'when default_value is 123' do
+        let(:base_param_description_options) do
+          { required: false, default_value: 123 }
+        end
+
+        it 'will not warn' do
+          expect { subject }.not_to output(
+            /is optional but default value is not specified/
+          ).to_stderr
+        end
+      end
+
+      context 'default_value not given' do
+        let(:base_param_description_options) { { required: false } }
+
+        it 'warns' do
+          expect { subject }.to output(
+            /is optional but default value is not specified/
+          ).to_stderr
+        end
+      end
+    end
+  end
+
+  describe '.with_type' do
+    subject { generated_block[:type] }
+
+    it { is_expected.to be_blank }
+
+    context 'when type is assigned' do
+      before { builder.with_type(with_null: false ) }
+
+      it { is_expected.to be_present }
+    end
+  end
+
+  describe '.with_description' do
+    subject { generated_block[:description] }
+
+    it { is_expected.to be_blank }
+
+    context 'when description is assigned' do
+      let(:param_description_options) { { desc: 'some-description' } }
+
+      before { builder.with_description(language: 'en') }
+
+      it { is_expected.to be_present }
+    end
+  end
+
+  describe '.with_name' do
+    subject { generated_block[:name] }
+
+    it { is_expected.to be_blank }
+
+    context 'when name is assigned' do
+      before { builder.with_name }
+
+      it { is_expected.to be_present }
+    end
+  end
+
+  describe '.with_in' do
+    subject { generated_block[:in] }
+
+    it { is_expected.to be_blank }
+
+    context 'when in is assigned' do
+      let(:in_schema) { false }
+
+      before { builder.with_in(http_method: 'get') }
+
+      it { is_expected.to be_present }
+    end
+  end
+
+  describe 'example' do
+    subject { generated_block[:example] }
+
+    it { is_expected.to be_blank }
+
+    context 'when example is assigned' do
+      let(:base_param_description_options) { { example: 'example' } }
+
+      it { is_expected.to eq('example') }
+    end
+  end
+end

data/spec/lib/apipie/generator/swagger/param_description/composite_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::ParamDescription::Composite do
+  let(:param_descriptions) {}
+
+  let(:dsl_data) { ActionController::Base.send(:_apipie_dsl_data_init) }
+
+  let(:resource_desc) do
+    Apipie::ResourceDescription.new(UsersController, "users")
+  end
+
+  let(:context) do
+    Apipie::Generator::Swagger::Context.new(
+      allow_null: true,
+      http_method: 'get',
+      controller_method: method_description
+    )
+  end
+
+  let(:method_description) do
+    Apipie::MethodDescription.new(:create, resource_desc, dsl_data)
+  end
+
+  let(:composite) { described_class.new(param_descriptions, context) }
+
+  let(:swagger) { composite.to_swagger }
+
+  let(:params_description_one) do
+    Apipie::ParamDescription.new(method_description, :some_param, String)
+  end
+
+  let(:params_description_two) do
+    Apipie::ParamDescription.new(method_description, :some_other_param, String)
+  end
+
+  let(:param_descriptions) { [params_description_one, params_description_two] }
+
+  context 'when no param descriptions are given' do
+    let(:param_descriptions) { [] }
+
+    subject { swagger }
+
+    it { is_expected.to be_blank }
+  end
+
+  describe 'additionalProperties' do
+    subject { swagger[:additionalProperties] }
+
+    it { is_expected.to be_falsey }
+
+    context 'when additional properties in response allowed' do
+      before do
+        Apipie.configuration.generator.swagger.allow_additional_properties_in_response = true
+      end
+
+      it { is_expected.to be_blank }
+    end
+  end
+
+  xdescribe 'nested additionalProperties' do
+    context 'when param description has nested params' do
+      let(:validator) do
+
+      end
+
+      let(:params_description_one) do
+        Apipie::ParamDescription.new(
+          method_description,
+          :some_param,
+          validator,
+          { required: true }
+        )
+      end
+    end
+  end
+
+  describe 'required' do
+    subject { swagger[:required] }
+
+    it { is_expected.to be_blank }
+
+    context 'when param description is required' do
+      let(:params_description_one) do
+        Apipie::ParamDescription.new(
+          method_description,
+          :some_param,
+          String,
+          { required: true }
+        )
+      end
+
+      it { is_expected.to be_truthy }
+    end
+  end
+end

data/spec/lib/apipie/generator/swagger/param_description/description_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::ParamDescription::Description do
+  let(:param_description_options) { {} }
+  let(:http_method) { :GET }
+  let(:path) { '/api' }
+  let(:validator) { String }
+  let(:language) {}
+
+  let(:base_dsl_data) do
+    {
+      :api => false,
+      :api_args => [],
+      :api_from_routes => nil,
+      :errors => [],
+      :tag_list => [],
+      :returns => {},
+      :params => [],
+      :headers => [],
+      :resource_id => nil,
+      :short_description => nil,
+      :description => nil,
+      :examples => [],
+      :see => [],
+      :formats => nil,
+      :api_versions => [],
+      :meta => nil,
+      :show => true,
+      :deprecated => false
+    }
+  end
+
+  let(:dsl_data) do
+    base_dsl_data.merge({
+      api_args: [
+        [
+          http_method,
+          path,
+          'description',
+          { deprecated: true }
+        ]
+      ]
+    })
+  end
+
+  let(:resource_desc) do
+    Apipie::ResourceDescription.new(UsersController, 'dummy')
+  end
+
+  let(:method_desc) do
+    Apipie::MethodDescription.new(:show, resource_desc, dsl_data)
+  end
+
+  let(:param_description) do
+    Apipie::ParamDescription.new(
+      method_desc,
+      :param,
+      validator,
+      param_description_options
+    )
+  end
+
+  let(:description_definition) do
+    described_class.new(param_description, language: language).to_hash
+  end
+
+  describe 'description' do
+    subject { description_definition[:description] }
+
+    it { is_expected.to be_blank }
+
+    context 'when desc is given to options' do
+      let(:desc) { 'Some description' }
+      let(:param_description_options) { { desc: desc } }
+
+      it { is_expected.to eq(desc) }
+    end
+  end
+end