apipie-rails 0.5.20 → 1.2.3

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

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::ParamDescription::Type do
+  let(:validator_options) { {} }
+  let(:param_description_options) { {}.merge(validator_options) }
+  let(:with_null) { false }
+  let(:http_method) { :GET }
+  let(:path) { '/api' }
+  let(:validator) { String }
+
+  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_name) { 'some_param' }
+
+  let(:param_description) do
+    Apipie::ParamDescription.new(
+      method_desc,
+      param_description_name,
+      validator,
+      param_description_options
+    )
+  end
+
+  let(:type_definition) do
+    described_class.
+      new(param_description, with_null: with_null, controller_method: 'index').
+      to_hash
+  end
+
+  describe 'type' do
+    subject { type_definition[:type] }
+
+    it { is_expected.to eq(validator.to_s.downcase) }
+
+    context 'when validator is enum' do
+      let(:validator) { %w[name enum] }
+
+      it { is_expected.to eq('string') }
+    end
+
+    context 'when validator is a Hash' do
+      let(:validator) { Hash }
+
+      it { is_expected.to eq('object') }
+    end
+  end
+
+  describe 'items' do
+    let(:items) { type_definition[:items] }
+
+    subject { items }
+
+    context 'when has validator is Array' do
+      let(:validator) { Array }
+
+      it { is_expected.to eq({ type: 'string' }) }
+
+      context 'of Hash' do
+        let(:validator_options) { { of: Hash } }
+
+        let(:reference) do
+          Apipie::Generator::Swagger::OperationId.
+            new(http_method: http_method, path: path, param: param_description_name).
+            to_s
+        end
+
+        it { is_expected.to eq({ type: 'string' }) }
+
+        context 'and swagger.json_input_uses_refs is set to true' do
+          before { Apipie.configuration.generator.swagger.json_input_uses_refs = true }
+          after { Apipie.configuration.generator.swagger.json_input_uses_refs = false }
+
+          it 'returns the reference' do
+            expect(subject).to eq({ '$ref' => reference })
+          end
+
+        end
+      end
+
+      describe 'enum' do
+        subject { items[:enum] }
+
+        it { is_expected.to be_blank }
+
+        context 'when validator is Array' do
+          let(:validator) { Array }
+
+          it { is_expected.to be_blank }
+
+          context 'and an array of in values is given' do
+            let(:enum_values) { %w[enum-value-1 enum-value-2] }
+            let(:validator_options) { { in: %w[enum-value-1 enum-value-2] } }
+
+            it { is_expected.to eq(enum_values) }
+          end
+        end
+      end
+    end
+  end
+
+  describe 'enum' do
+    subject { type_definition[:enum] }
+
+    context 'and an array of in values is given' do
+      let(:validator) { %w[enum-value-1 enum-value-2] }
+
+      it { is_expected.to eq(validator) }
+    end
+  end
+
+  describe 'additionalProperties' do
+    subject { type_definition[:additionalProperties] }
+
+    it  { is_expected.to be_blank }
+
+    context 'when validator is a Hash' do
+      let(:validator) { Hash }
+
+      it { is_expected.to be_truthy }
+    end
+  end
+
+  describe 'warnings' do
+    before { Singleton.__init__(Apipie::Generator::Swagger::WarningWriter) }
+
+    subject { type_definition }
+
+    context 'when validator is a Hash' do
+      let(:validator) { Hash }
+
+      it 'outputs a hash without internal typespec warning' do
+        expect { subject }.to output(/is a generic Hash without an internal type specification/).to_stderr
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::ParamDescription do
+  describe '.create_for_missing_param' do
+    let(:name) { 'ok' }
+
+    let(:method_description) do
+      Apipie.get_method_description(UsersController, :update)
+    end
+
+    subject do
+      described_class.create_for_missing_param(method_description, name)
+    end
+
+    it 'creates a required param description' do
+      expect(subject.required).to eq(true)
+    end
+
+    it 'has the correct name' do
+      expect(subject.name).to eq(name)
+    end
+
+    it 'has been created from path' do
+      expect(subject.options[:added_from_path]).to eq(true)
+    end
+  end
+end
+

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

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::PathDecorator do
+  let(:decorated_path) { described_class.new(path) }
+
+  describe '#param_names' do
+    subject { decorated_path.param_names }
+
+    context 'when path does not contain any params' do
+      let(:path) { 'some/path/without_params' }
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'when path has a param' do
+      let(:path) { '/:resource_id/custom' }
+
+      it { is_expected.to eq([:resource_id]) }
+    end
+  end
+
+  describe '#param?' do
+    subject { decorated_path.param?(param) }
+
+    context 'when path has params' do
+      let(:path) { '/:resource_id/custom' }
+
+      context 'when param to check is in the path' do
+        let(:param) { :resource_id }
+
+        it { is_expected.to be(true) }
+      end
+
+      context 'when param to check is not in the path' do
+        let(:param) { :some_param }
+
+        it { is_expected.to be(false) }
+      end
+    end
+  end
+
+  describe '#swagger_path' do
+    subject(:swagger_path) { decorated_path.swagger_path }
+
+    let(:path) { '/some/custom/path' }
+
+    it { is_expected.to eq('/some/custom/path') }
+
+    context 'when path does not start with slash' do
+      let(:path) { ':resource_id/custom' }
+
+      it 'adds the slash in the beginning' do
+        expect(swagger_path).to eq('/{resource_id}/custom')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::ReferencedDefinitions do
+  let(:definitions) { described_class.instance }
+
+  before { Singleton.__init__(described_class) }
+
+  describe '.add!' do
+    subject(:add_call) { definitions.add!(param_type, schema) }
+
+    let(:param_type) { :some_type }
+    let(:schema) { { key: 'value' } }
+
+    it 'returns add the definition' do
+      expect { add_call }
+        .to change(definitions, :definitions)
+        .from({})
+        .to({ param_type => schema })
+    end
+  end
+
+  describe '.added?' do
+    subject { definitions.added?(param_type) }
+
+    let(:param_type) { :some_type }
+
+    it { is_expected.to be_blank }
+
+    context 'when definition exists' do
+      before { definitions.add!(param_type, {}) }
+
+      it { is_expected.to be(true) }
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::ResourceDescriptionComposite do
+  let(:dsl_data) { {} }
+  let(:resource_id) { 'pets' }
+  let(:resource_description) do
+    Apipie::ResourceDescription.new(PetsController, resource_id, dsl_data)
+  end
+
+  let(:resource_descriptions) { [resource_description] }
+  let(:composite) { described_class.new(resource_descriptions, language: :en) }
+
+  describe '#to-swagger' do
+    subject { composite.to_swagger }
+
+    it { is_expected.to include(:paths, :tags) }
+
+    describe 'tags' do
+      subject(:tag) { composite.to_swagger[:tags].first }
+
+      it { is_expected.to be_blank }
+
+      context 'when resource description has full description' do
+        let(:dsl_data) { { description: 'something' } }
+
+        it 'returns the name and description' do
+          expect(tag).to eq(
+            {
+              name: resource_id,
+              description: resource_description._full_description
+            }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::ResourceDescriptionsCollection do
+  let(:collection) { described_class.new(resource_descriptions) }
+
+  let(:users_resource_description) do
+    Apipie.get_resource_description(UsersController, Apipie.configuration.default_version)
+  end
+
+  let(:pets_resource_description) do
+    Apipie.get_resource_description(PetsController, Apipie.configuration.default_version)
+  end
+
+  let(:resource_descriptions) do
+    {
+      'development' => {
+        users_resource_description._id => users_resource_description,
+        pets_resource_description._id => pets_resource_description
+      },
+      'production' => {
+        pets_resource_description._id => pets_resource_description
+      }
+    }
+  end
+
+  describe '#filter' do
+    subject(:filtered_resource_descriptions) do
+      collection.filter(
+        version: version,
+        resource_id: resource_id,
+        method_name: method_name
+      )
+    end
+
+    let(:version) { 'development' }
+    let(:resource_id) { users_resource_description._id }
+    let(:method_name) { nil }
+
+    it 'filters resources for the given version and resource name' do
+      expect(filtered_resource_descriptions).to eq([users_resource_description])
+    end
+
+    context 'when method name is given' do
+      context 'when does not exist in the controller' do
+        let(:method_name) { :i_do_not_exist }
+
+        it { is_expected.to be_empty }
+      end
+
+      context 'when exists in the controller' do
+        let(:method_name) { :show }
+
+        it { is_expected.to eq([users_resource_description]) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::Schema do
+  let(:version) { :ok }
+  let(:language) { :ok }
+  let(:clear_warnings) { :ok }
+  let(:dsl_data) { {} }
+  let(:resource_id) { 'pets' }
+  let(:resource_descriptions) { [resource_description] }
+
+  let(:resource_description) do
+    Apipie::ResourceDescription.new(PetsController, resource_id, dsl_data)
+  end
+
+  let(:schema_generator) do
+    described_class.new(
+      resource_descriptions,
+      version: version,
+      language: language,
+      clear_warnings: clear_warnings
+    )
+  end
+
+  describe '#generate' do
+    subject(:schema) { schema_generator.generate }
+
+    describe 'host' do
+      before { Apipie.configuration.generator.swagger.api_host = nil }
+
+      it 'is not returned' do
+        expect(schema.keys).not_to include(:host)
+      end
+
+      context 'when api_host is set' do
+        let(:host) { 'localhost:3000' }
+
+        before { Apipie.configuration.generator.swagger.api_host = host }
+
+        it 'returns the host' do
+          expect(schema[:host]).to eq(host)
+        end
+      end
+    end
+
+    describe 'consumes' do
+      subject { schema_generator.generate[:consumes] }
+
+      before { Apipie.configuration.generator.swagger.content_type_input = nil }
+
+      it { is_expected.to eq(['application/x-www-form-urlencoded', 'multipart/form-data']) }
+
+      context 'when swagger.content_type_input is set to json' do
+        before { Apipie.configuration.generator.swagger.content_type_input = :json }
+
+        it { is_expected.to eq(['application/json']) }
+      end
+    end
+
+    describe 'title' do
+      subject { schema_generator.generate[:info][:title] }
+
+      before { Apipie.configuration.generator.swagger.content_type_input = nil }
+
+      it { is_expected.to include(' (params in:formData)') }
+
+      context 'when swagger.content_type_input is set to json' do
+        before { Apipie.configuration.generator.swagger.content_type_input = :json }
+
+        it { is_expected.to include(' (params in:body)') }
+      end
+    end
+
+    describe 'x-computed-id' do
+      subject(:schema) { schema_generator.generate[:info] }
+
+      before { Apipie.configuration.generator.swagger.generate_x_computed_id_field = false }
+
+      it 'is not returned' do
+        expect(schema.keys).not_to include('x-computed-id')
+      end
+
+      context 'when swagger.content_type_input is set to json' do
+        before { Apipie.configuration.generator.swagger.generate_x_computed_id_field = true }
+
+        it { is_expected.to include('x-computed-id') }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::TypeExtractor do
+  let(:extractor) { described_class.new(validator) }
+
+  shared_examples 'extractable method' do
+    let(:warnings) { {} }
+    let(:validator) {}
+
+    it { is_expected.to eq(Apipie::Generator::Swagger::TypeExtractor::TYPES[:string]) }
+
+    context "when enum validator is used" do
+      let(:enum_values) { ["Name"] }
+
+      context "of type Apipie::Validator::EnumValidator" do
+        let(:validator) { Apipie::Validator::EnumValidator.new(nil, enum_values) }
+
+        it { is_expected.to eq("enum") }
+      end
+
+      context "that responds to is_enum?" do
+        let(:validator) do
+          Apipie::ResponseDescriptionAdapter::PropDesc::Validator.new('some-type', enum_values)
+        end
+
+        it 'returns an enum type' do
+          expect(subject).to eq(Apipie::Generator::Swagger::TypeExtractor::TYPES[:enum])
+        end
+      end
+    end
+  end
+
+  describe '#extract' do
+    subject { extractor.extract }
+
+    it_behaves_like 'extractable method'
+  end
+end

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

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Apipie::Generator::Swagger::Warning do
+  let(:code) { Apipie::Generator::Swagger::Warning::MISSING_METHOD_SUMMARY_CODE }
+  let(:method_id) { 'Examples#index' }
+  let(:info_message) { 'Something went wrong' }
+
+  let(:warning) { described_class.new(code, info_message, method_id) }
+
+  describe '#id' do
+    subject { warning.id }
+
+    it { is_expected.to eq("#{method_id}#{code}#{info_message}") }
+  end
+
+  describe '#warning_message' do
+    subject { warning.warning_message }
+
+    it { is_expected.to eq("WARNING (#{code}): [#{method_id}] -- #{info_message}\n") }
+  end
+
+  describe '#warn' do
+    subject { warning.warn }
+
+    it 'outputs the warning' do
+      expect { subject }.to output(warning.warning_message).to_stderr
+    end
+  end
+
+  describe '#warn_through_writer' do
+    subject { warning.warn }
+
+    it 'outputs the warning' do
+      expect { subject }.to output(warning.warning_message).to_stderr
+    end
+  end
+
+  describe '.for_code' do
+    subject { described_class.for_code(code, method_id) }
+
+    it { is_expected.to be_an_instance_of(described_class)}
+
+    context 'when code is invalid' do
+      let(:code) { 12345 }
+
+      it 'raises an argument error' do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::WarningWriter do
+  let(:writer) { described_class.clone.instance }
+
+  let(:warning) do
+    Apipie::Generator::Swagger::Warning.for_code(
+      Apipie::Generator::Swagger::Warning::PARAM_IGNORED_IN_FORM_DATA_CODE,
+      'SampleController#action',
+      { parameter: 'some-param' }
+    )
+  end
+
+  before do
+    Apipie.configuration.generator.swagger.suppress_warnings = false
+    Singleton.__init__(described_class)
+  end
+
+  describe '#warn' do
+    subject { writer.warn(warning) }
+
+    it 'outputs the warning' do
+      expect { subject }.to output(warning.warning_message).to_stderr
+    end
+
+    context 'when Apipie.configuration.generator.swagger.suppress_warnings is true' do
+      before { Apipie.configuration.generator.swagger.suppress_warnings = true }
+
+      it { is_expected.to be_falsey }
+    end
+
+    context 'when Apipie.configuration.generator.swagger.suppress_warnings includes warning code' do
+      before do
+        Apipie.configuration.generator.swagger.suppress_warnings =
+          Array(Apipie::Generator::Swagger::Warning::PARAM_IGNORED_IN_FORM_DATA_CODE)
+      end
+
+      it { is_expected.to be_falsey }
+    end
+
+    context 'when a warning already been logged' do
+      before { writer.warn(warning) }
+
+      it { is_expected.to be_falsey }
+    end
+  end
+
+  describe '#issued_warnings?' do
+    subject { writer.issued_warnings? }
+
+    it { is_expected.to be_falsey }
+
+    context 'when a warning already been logged' do
+      before { writer.warn(warning) }
+
+      it { is_expected.to be_truthy }
+    end
+  end
+
+  describe '#clear!' do
+    subject { writer.clear! }
+
+    context 'when writer has issued warnings' do
+      before { writer.warn(warning) }
+
+      it 'removes issued warnings' do
+        expect { subject }.to change(writer, :issued_warnings?).from(true).to(false)
+      end
+    end
+  end
+end