apipie-rails 0.9.4 → 1.0.0

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

@@ -75,7 +75,7 @@ describe Apipie::Generator::Swagger::ParamDescription::Type do
     it { is_expected.to eq(validator.to_s.downcase) }
 
     context 'when validator is enum' do
-      let(:validator) { ['name', 'enum'] }
+      let(:validator) { %w[name enum] }
 
       it { is_expected.to eq('string') }
     end
@@ -108,9 +108,9 @@ describe Apipie::Generator::Swagger::ParamDescription::Type do
 
         it { is_expected.to eq({ type: 'string' }) }
 
-        context 'and swagger_json_input_uses_refs is set to true' do
-          before { Apipie.configuration.swagger_json_input_uses_refs = true }
-          after { Apipie.configuration.swagger_json_input_uses_refs = false }
+        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 })
@@ -130,8 +130,8 @@ describe Apipie::Generator::Swagger::ParamDescription::Type do
           it { is_expected.to be_blank }
 
           context 'and an array of in values is given' do
-            let(:enum_values) { ['enum-value-1', 'enum-value-2'] }
-            let(:validator_options) { { in: ['enum-value-1', 'enum-value-2'] } }
+            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
@@ -144,7 +144,7 @@ describe Apipie::Generator::Swagger::ParamDescription::Type do
     subject { type_definition[:enum] }
 
     context 'and an array of in values is given' do
-      let(:validator) { ['enum-value-1', 'enum-value-2'] }
+      let(:validator) { %w[enum-value-1 enum-value-2] }
 
       it { is_expected.to eq(validator) }
     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

@@ -26,15 +26,6 @@ describe Apipie::Generator::Swagger::TypeExtractor do
         it 'returns an enum type' do
           expect(subject).to eq(Apipie::Generator::Swagger::TypeExtractor::TYPES[:enum])
         end
-
-        context 'and has `true`, `false` as values' do
-          let(:param_description_name) { :visible }
-          let(:enum_values) { [true, false] }
-
-          it 'returns a boolean type' do
-            expect(subject).to eq(Apipie::Generator::Swagger::TypeExtractor::TYPES[:boolean])
-          end
-        end
       end
     end
   end
@@ -44,38 +35,4 @@ describe Apipie::Generator::Swagger::TypeExtractor do
 
     it_behaves_like 'extractable method'
   end
-
-  describe '#extarct_with_warnings' do
-    before { Apipie.configuration.swagger_suppress_warnings = false }
-
-    subject { extractor.extract_with_warnings(warnings) }
-
-    it_behaves_like 'extractable method'
-
-    context "when enum validator is used" do
-      context "and has `true`, `false` as values" do
-        let(:enum_values) { [true, false] }
-
-        let(:validator) do
-          Apipie::ResponseDescriptionAdapter::PropDesc::Validator.new('some-type', enum_values)
-        end
-
-        context 'and a boolean warning is passed' do
-          let(:boolean_warning) do
-            Apipie::Generator::Swagger::Warning.for_code(
-              Apipie::Generator::Swagger::Warning::INFERRING_BOOLEAN_CODE,
-              'SampleController#action',
-              { parameter: 'some-param' }
-            )
-          end
-
-          let(:warnings) { { boolean: boolean_warning } }
-
-          it 'outputs the warning' do
-            expect { subject }.to output(boolean_warning.warning_message).to_stderr
-          end
-        end
-      end
-    end
-  end
 end

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

@@ -16,7 +16,7 @@ describe Apipie::Generator::Swagger::Warning do
   describe '#warning_message' do
     subject { warning.warning_message }
 
-    it { is_expected.to eq("WARNING (#{code}): [#{method_id}] -- #{info_message}") }
+    it { is_expected.to eq("WARNING (#{code}): [#{method_id}] -- #{info_message}\n") }
   end
 
   describe '#warn' do

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

@@ -5,14 +5,14 @@ describe Apipie::Generator::Swagger::WarningWriter do
 
   let(:warning) do
     Apipie::Generator::Swagger::Warning.for_code(
-      Apipie::Generator::Swagger::Warning::INFERRING_BOOLEAN_CODE,
+      Apipie::Generator::Swagger::Warning::PARAM_IGNORED_IN_FORM_DATA_CODE,
       'SampleController#action',
       { parameter: 'some-param' }
     )
   end
 
   before do
-    Apipie.configuration.swagger_suppress_warnings = false
+    Apipie.configuration.generator.swagger.suppress_warnings = false
     Singleton.__init__(described_class)
   end
 
@@ -23,16 +23,16 @@ describe Apipie::Generator::Swagger::WarningWriter do
       expect { subject }.to output(warning.warning_message).to_stderr
     end
 
-    context 'when Apipie.configuration.swagger_suppress_warnings is true' do
-      before { Apipie.configuration.swagger_suppress_warnings = true }
+    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.swagger_suppress_warnings includes warning code' do
+    context 'when Apipie.configuration.generator.swagger.suppress_warnings includes warning code' do
       before do
-        Apipie.configuration.swagger_suppress_warnings =
-          Array(Apipie::Generator::Swagger::Warning::INFERRING_BOOLEAN_CODE)
+        Apipie.configuration.generator.swagger.suppress_warnings =
+          Array(Apipie::Generator::Swagger::Warning::PARAM_IGNORED_IN_FORM_DATA_CODE)
       end
 
       it { is_expected.to be_falsey }
@@ -56,4 +56,16 @@ describe Apipie::Generator::Swagger::WarningWriter do
       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

data/spec/lib/apipie/method_description_spec.rb

@@ -1,98 +1,133 @@
 require "spec_helper"
 
 describe Apipie::MethodDescription do
-
   let(:dsl_data) { ActionController::Base.send(:_apipie_dsl_data_init) }
+  let(:deprecated_resource_description) { false }
+  let(:method_description_method) { :some_method }
 
-  describe "metadata" do
+  let(:resource_description_dsl) do
+    ActionController::Base.send(:_apipie_dsl_data_init).merge(
+      {
+        deprecated: deprecated_resource_description
+      }
+    )
+  end
 
-    before(:each) do
-      @resource = Apipie::ResourceDescription.new(ApplicationController, "dummy")
-    end
+  let(:resource_description) do
+    Apipie::ResourceDescription.new(
+      ApplicationController,
+      'dummy',
+      resource_description_dsl
+    )
+  end
 
-    it "should return nil when no metadata is provided" do
-      method = Apipie::MethodDescription.new(:a, @resource, dsl_data)
-      expect(method.to_json[:metadata]).to eq(nil)
-    end
+  let(:method_description) do
+    Apipie::MethodDescription.new(
+      method_description_method,
+      resource_description,
+      dsl_data
+    )
+  end
 
-    it "should return the metadata" do
-      meta = {
-        :lenght => 32,
-        :weight => '830g'
-      }
-      method = Apipie::MethodDescription.new(:a, @resource, dsl_data.update(:meta => meta))
-      expect(method.to_json[:metadata]).to eq(meta)
-    end
+  describe '#to_json' do
+    describe 'metadata' do
+      subject { method_description.to_json[:metadata] }
 
-  end
+      it { is_expected.to be_nil }
 
-  describe "deprecated flag" do
-    before(:each) do
-      @resource = Apipie::ResourceDescription.new(ApplicationController, "dummy")
-    end
+      context 'when meta are given' do
+        let(:meta) { { length: 32, weight: '830g' } }
+        let(:dsl_data) { super().merge(meta: meta) }
 
-    it "should return the deprecated flag when provided" do
-      dsl_data[:api_args] = [[:GET, "/foo/bar", "description", {:deprecated => true}]]
-      method = Apipie::MethodDescription.new(:a, @resource, dsl_data)
-      expect(method.method_apis_to_json.first[:deprecated]).to eq(true)
+        it { is_expected.to eq(meta) }
+      end
     end
 
-    it "should return the deprecated flag if resource is deprecated" do
-      @resource.instance_variable_set("@_deprecated", true)
-      dsl_data[:api_args] = [[:GET, "/foo/bar", "description", {}]]
-      method = Apipie::MethodDescription.new(:a, @resource, dsl_data)
-      expect(method.method_apis_to_json.first[:deprecated]).to eq(true)
+    describe 'params' do
+      subject(:json_params) { method_description.to_json[:params].map { |h| h[:name] } }
+
+      let(:dsl_data) do
+        super().merge(
+          {
+            params: [
+              [:a, String, nil, {}, nil],
+              [:b, String, nil, {}, nil],
+              [:c, String, nil, {}, nil]
+            ]
+          }
+        )
+      end
+
+      it 'should be ordered' do
+        expect(json_params).to eq(%w[a b c])
+      end
+
+      context 'when param is only for response' do
+        let(:dsl_data) do
+          super().merge(
+            {
+              params: [
+                [:a, String, nil, { only_in: :request }, nil],
+                [:b, String, nil, { only_in: :response }, nil],
+                [:c, String, nil, {}, nil]
+              ]
+            }
+          )
+        end
+
+        it 'should ignore response-only parameters' do
+          expect(json_params).to eq(%w[a c])
+        end
+      end
     end
   end
 
-  describe "params descriptions" do
+  describe '#method_apis_to_json' do
+    describe 'deprecated' do
+      subject { method_description.method_apis_to_json.first[:deprecated] }
 
-    before(:each) do
-      @resource = Apipie::ResourceDescription.new(ApplicationController, "dummy")
-      dsl_data[:params] = [[:a, String, nil, {}, nil],
-                           [:b, String, nil, {}, nil],
-                           [:c, String, nil, {}, nil]]
-      @method = Apipie::MethodDescription.new(:a, @resource, dsl_data)
-      @resource.add_method_description @method
-    end
+      let(:api_deprecated) { false }
+      let(:dsl_data) { super().merge(api_args: api_args) }
 
-    it "should be ordered" do
-      expect(@method.params.keys).to eq([:a, :b, :c])
-      expect(@method.to_json[:params].map { |h| h[:name] }).to eq(['a', 'b', 'c'])
-    end
+      let(:api_args) do
+        [[:GET, "/foo/bar", "description", { deprecated: api_deprecated }]]
+      end
 
-    it "should be still ordered" do
-      expect(@method.params.keys).to eq([:a, :b, :c])
-      expect(@method.to_json[:params].map { |h| h[:name] }).to eq(['a', 'b', 'c'])
-    end
+      it { is_expected.to eq(false) }
 
-  end
+      context 'when api is deprecated' do
+        let(:api_deprecated) { true }
 
-  describe "response-only properties" do
-    before(:each) do
-      @resource = Apipie::ResourceDescription.new(ApplicationController, "dummy")
-      dsl_data[:params] = [[:a, String, nil, {:only_in => :request}, nil],
-                           [:b, String, nil, {:only_in => :response}, nil],
-                           [:c, String, nil, {}, nil]]
-      @method = Apipie::MethodDescription.new(:a, @resource, dsl_data)
-      @resource.add_method_description @method
-    end
+        it { is_expected.to eq(true) }
+      end
+
+      context 'when resource description is deprecated' do
+        let(:deprecated_resource_description) { true }
 
-    it "should ignore response-only parameters" do
-      expect(@method.params.keys).to eq([:a, :c])
-      expect(@method.to_json[:params].map { |h| h[:name] }).to eq(['a', 'c'])
+        it { is_expected.to eq(true) }
+      end
     end
   end
 
+  describe '#returns' do
+    subject(:method_desc) { method_description }
 
-  describe "'returns' properties" do
-    it "should raise an error if both :param_group and :array_of are specified in 'returns'" do
-      @resource = Apipie::ResourceDescription.new(ApplicationController, "dummy")
-      dsl_data[:returns] = { 200 => [{:param_group => 'pet', :array_of => 'pet'}, nil, nil] }
+    context 'when both :param_group and :array_of are specified' do
+      let(:returns) do
+        { 200 => [{ param_group: 'pet', array_of: 'pet' }, nil, nil] }
+      end
 
-      expect { Apipie::MethodDescription.new(:a, @resource, dsl_data) }.to raise_error(Apipie::ReturnsMultipleDefinitionError)
+      let(:dsl_data) { super().merge({ returns: returns }) }
+
+      it 'raises an error' do
+        expect { method_desc }.to raise_error(Apipie::ReturnsMultipleDefinitionError)
+      end
     end
   end
 
+  describe '#method_name' do
+    subject { method_description.method_name }
 
+    it { is_expected.to eq(method_description_method.to_s) }
+  end
 end