apipie-rails 0.5.20 → 1.2.3

data/spec/lib/apipie/method_description/apis_service_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Apipie::MethodDescription::ApisService do
+  let(:resource) {}
+  let(:controller_action) {}
+  let(:api_args) { [] }
+  let(:dsl) { { api_args: api_args } }
+  let(:service) { described_class.new(resource, controller_action, dsl) }
+
+  describe '#call' do
+    subject { service.call }
+
+    it { is_expected.to eq(api_args) }
+
+    context 'when api_from_routes is given' do
+      let(:controller) { UsersController }
+      let(:controller_action) { :show }
+      let(:resource) { Apipie::ResourceDescription.new(controller, 'dummy') }
+      let(:short_description) { 'Short description' }
+
+      let(:dsl) do
+        super().merge({
+          api_from_routes: {
+            desc: short_description,
+            options: {}
+          }
+        })
+      end
+
+      it 'returns an array of Apipie::MethodDescription::Api' do
+        expect(subject).to all(be_an_instance_of(Apipie::MethodDescription::Api))
+        expect(subject.count).to eq(1)
+      end
+
+      context 'Apipie::MethodDescription::Api' do
+        subject { service.call.first }
+
+        it 'has the correct values' do
+          expect(subject.short_description).to eq(short_description)
+          expect(subject.path).to eq('/api/users/:id')
+          expect(subject.from_routes).to eq(true)
+          expect(subject.options).to eq({ from_routes: true })
+        end
+
+        context "when it's from concern" do
+          let(:controller) { ConcernsController }
+          let(:controller_action) { :custom }
+          let(:dsl) { super().merge(from_concern: true ) }
+
+          it 'has the correct values' do
+            expect(subject.short_description).to eq(short_description)
+            expect(subject.path).to eq('/api/concern_resources/custom')
+            expect(subject.from_routes).to eq(true)
+            expect(subject.options).to eq({ from_routes: true })
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/apipie/method_description_spec.rb

@@ -0,0 +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 }
+
+  let(:resource_description_dsl) do
+    ActionController::Base.send(:_apipie_dsl_data_init).merge(
+      {
+        deprecated: deprecated_resource_description
+      }
+    )
+  end
+
+  let(:resource_description) do
+    Apipie::ResourceDescription.new(
+      ApplicationController,
+      'dummy',
+      resource_description_dsl
+    )
+  end
+
+  let(:method_description) do
+    Apipie::MethodDescription.new(
+      method_description_method,
+      resource_description,
+      dsl_data
+    )
+  end
+
+  describe '#to_json' do
+    describe 'metadata' do
+      subject { method_description.to_json[:metadata] }
+
+      it { is_expected.to be_nil }
+
+      context 'when meta are given' do
+        let(:meta) { { length: 32, weight: '830g' } }
+        let(:dsl_data) { super().merge(meta: meta) }
+
+        it { is_expected.to eq(meta) }
+      end
+    end
+
+    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 '#method_apis_to_json' do
+    describe 'deprecated' do
+      subject { method_description.method_apis_to_json.first[:deprecated] }
+
+      let(:api_deprecated) { false }
+      let(:dsl_data) { super().merge(api_args: api_args) }
+
+      let(:api_args) do
+        [[:GET, "/foo/bar", "description", { deprecated: api_deprecated }]]
+      end
+
+      it { is_expected.to eq(false) }
+
+      context 'when api is deprecated' do
+        let(:api_deprecated) { true }
+
+        it { is_expected.to eq(true) }
+      end
+
+      context 'when resource description is deprecated' do
+        let(:deprecated_resource_description) { true }
+
+        it { is_expected.to eq(true) }
+      end
+    end
+  end
+
+  describe '#returns' do
+    subject(:method_desc) { method_description }
+
+    context 'when both :param_group and :array_of are specified' do
+      let(:returns) do
+        { 200 => [{ param_group: 'pet', array_of: 'pet' }, nil, nil] }
+      end
+
+      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

data/spec/lib/apipie/no_documented_method_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Apipie::NoDocumentedMethod do
+  let(:error) { described_class.new(controller_name, method_name) }
+  let(:controller_name) { 'UserController' }
+  let(:method_name) { 'index' }
+
+  describe '#to_s' do
+    subject { error.to_s }
+
+    let(:error_message) do
+      "There is no documented method #{controller_name}##{method_name}"
+    end
+
+    it { is_expected.to eq(error_message) }
+  end
+end

data/spec/lib/apipie/param_description/deprecation_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Apipie::ParamDescription::Deprecation do
+  let(:info) { nil }
+  let(:deprecated_in) { nil }
+  let(:sunset_at) { nil }
+
+  let(:deprecation) do
+    described_class.new(
+      info: info,
+      deprecated_in: deprecated_in,
+      sunset_at: sunset_at
+    )
+  end
+
+  describe '#to_json' do
+    subject { deprecation.to_json }
+
+    it { is_expected.to eq({ info: nil, deprecated_in: nil, sunset_at: nil }) }
+
+    context 'when attributes are given' do
+      let(:info) { 'info' }
+      let(:deprecated_in) { '2.3' }
+      let(:sunset_at) { '3.0' }
+
+      it 'returns the correct attributes' do
+        expect(subject).to eq({ info: info, deprecated_in: deprecated_in, sunset_at: sunset_at })
+      end
+    end
+  end
+end

data/spec/lib/{param_description_spec.rb → apipie/param_description_spec.rb}

@@ -113,6 +113,216 @@ describe Apipie::ParamDescription do
 
   end
 
+  describe 'validate' do
+    subject { param_description.validate(validation_value) }
+
+    let(:allow_blank) { nil }
+
+    let(:param_description) do
+      Apipie::ParamDescription.new(
+        method_desc,
+        :param,
+        validation_type,
+        allow_blank: allow_blank
+      )
+    end
+
+    context 'when allow_blank is ignored, as it was before 0.7.0' do
+      before { Apipie.configuration.ignore_allow_blank_false = true }
+      after { Apipie.configuration.ignore_allow_blank_false = false }
+
+      context 'when validation type is :boolean' do
+        let(:validation_type) { :boolean }
+
+        context 'when validation value is false' do
+          let(:validation_value) { false }
+
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
+          end
+        end
+
+        context 'when validation value is an empty string' do
+          let(:validation_value) { '' }
+
+          it 'should raise an error' do
+            expect { subject }.to raise_error(Apipie::ParamInvalid)
+          end
+        end
+      end
+
+      context 'when validation type is a boolean array' do
+        let(:validation_type) { [true, false] }
+
+        context 'when validation value is false' do
+          let(:validation_value) { false }
+
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
+          end
+        end
+
+        context 'when validation value is true' do
+          let(:validation_value) { true }
+
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
+          end
+        end
+
+        context 'when validation value is an empty string' do
+          let(:validation_value) { '' }
+
+          it 'should raise an error' do
+            expect { subject }.to raise_error(Apipie::ParamInvalid)
+          end
+        end
+      end
+
+      context 'when validation type is String' do
+        let(:validation_type) { String }
+
+        context 'when validation value is empty string' do
+          let(:validation_value) { '' }
+
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
+          end
+
+          context 'when allow_blank is specified as true' do
+            let(:allow_blank) { true }
+
+            it 'should not raise an error' do
+              expect { subject }.not_to raise_error
+            end
+          end
+        end
+      end
+    end
+
+    context 'when the validation type is :boolean' do
+      let(:validation_type) { :boolean }
+
+      context 'when validation value' do
+        let(:validation_value) { false }
+
+        it 'should not raise an error' do
+          expect { subject }.not_to raise_error
+        end
+
+        context 'when allow_blank is false' do
+          let(:allow_blank) { false }
+
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
+          end
+        end
+
+        context 'when allow_blank is true' do
+          let(:allow_blank) { true }
+
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
+          end
+        end
+      end
+
+      context 'when validation value is empty string' do
+        let(:validation_value) { '' }
+
+        it 'should raise an error' do
+          expect { subject }.to raise_error(Apipie::ParamInvalid)
+        end
+      end
+    end
+
+    context 'when validation type is a boolean array' do
+      let(:validation_type) { [true, false] }
+
+      context 'when validation value is false' do
+        let(:validation_value) { false }
+
+        it 'should not raise an error' do
+          expect { subject }.not_to raise_error
+        end
+      end
+
+      context 'when validation value is true' do
+        let(:validation_value) { true }
+
+        it 'should not raise an error' do
+          expect { subject }.not_to raise_error
+        end
+      end
+
+      context 'when validation value is an empty string' do
+        let(:validation_value) { '' }
+
+        it 'should raise an error' do
+          expect { subject }.to raise_error(Apipie::ParamInvalid)
+        end
+      end
+    end
+
+    context 'when the validation type is a custom one' do
+      let(:validation_type) { :custom_bool }
+
+      context 'when ignore_allow_blank? returning true' do
+        before do
+          allow(CustomBoolValidator).to receive(:ignore_allow_blank?).and_return(true)
+        end
+
+        context 'when a blank but valid value is passed' do
+          let(:validation_value) { false }
+
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
+          end
+
+          context 'when allow_blank is false' do
+            let(:allow_blank) { false }
+
+            it 'should not raise an error' do
+              expect { subject }.not_to raise_error
+            end
+          end
+        end
+
+        context 'when a blank but invalid value is passed' do
+          let(:validation_value) { '' }
+
+          it 'should raise an error' do
+            expect { subject }.to raise_error(Apipie::ParamInvalid)
+          end
+        end
+      end
+    end
+
+    context 'when validation type is String' do
+      let(:validation_type) { String }
+
+      context 'when a blank but invalid value is passed' do
+        let(:validation_value) { '' }
+
+        it 'should raise an error' do
+          expect { subject }.to raise_error(Apipie::ParamInvalid)
+        end
+      end
+
+      context 'when allow_blank is specified as true' do
+        let(:allow_blank) { true }
+
+        context 'when and empty string is given' do
+          let(:validation_value) { '' }
+
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
+          end
+        end
+      end
+    end
+  end
+
   describe "concern substitution" do
 
     let(:concern_dsl_data) { dsl_data.merge(:from_concern => true) }
@@ -151,7 +361,6 @@ describe Apipie::ParamDescription do
     end
   end
 
-
   describe "required_by_default config option" do
     context "parameters required by default" do
 
@@ -281,14 +490,13 @@ describe Apipie::ParamDescription do
     end
   end
 
-
   describe 'sub params' do
 
     context 'with HashValidator' do
 
       subject do
         Apipie::ParamDescription.new(method_desc, :param, Hash) do
-          param :answer, Fixnum
+          param :answer, Integer
         end
       end
 
@@ -306,7 +514,7 @@ describe Apipie::ParamDescription do
 
       subject do
         Apipie::ParamDescription.new(method_desc, :param, Array) do
-          param :answer, Fixnum
+          param :answer, Integer
         end
       end
 
@@ -336,10 +544,128 @@ describe Apipie::ParamDescription do
 
   describe "Array with classes" do
     it "should be valid for objects included in class array" do
-      param = Apipie::ParamDescription.new(method_desc, :param, [Fixnum, String])
+      param = Apipie::ParamDescription.new(method_desc, :param, [Integer, String])
       expect { param.validate("1") }.not_to raise_error
-      expect { param.validate(Fixnum) }.to raise_error(Apipie::ParamInvalid)
+      expect { param.validate(Integer) }.to raise_error(Apipie::ParamInvalid)
     end
   end
 
+  describe '#deprecated?' do
+    subject do
+      Apipie::ParamDescription.new(method_desc, :param, Integer, options)
+    end
+
+    let(:options) { {} }
+
+    it { is_expected.not_to be_deprecated }
+
+    context 'when deprecated option is passed' do
+      context 'and is true' do
+        let(:options) { { deprecated: true } }
+
+        it { is_expected.to be_deprecated }
+      end
+
+      context 'and is false' do
+        let(:options) { { deprecated: false } }
+
+        it { is_expected.not_to be_deprecated }
+      end
+
+      context 'and is a string' do
+        let(:options) { { deprecated: 'Some description' } }
+
+        it { is_expected.to be_deprecated }
+      end
+
+      context 'and deprecation options are given' do
+        let(:options) do
+          { deprecated: { in: '2.3', info: 'Something', sunset: '3.0' } }
+        end
+
+        it { is_expected.to be_deprecated }
+      end
+    end
+  end
+
+  describe '#deprecation' do
+    subject { param_description.deprecation }
+
+    let(:options) { {} }
+
+    let(:param_description) do
+      Apipie::ParamDescription.new(method_desc, :param, Integer, options)
+    end
+
+    it { is_expected.to be_blank }
+
+    context 'when deprecated option is passed' do
+      context 'and is true' do
+        let(:options) { { deprecated: true } }
+
+        it { is_expected.to be_blank }
+      end
+
+      context 'and is false' do
+        let(:options) { { deprecated: false } }
+
+        it { is_expected.to be_blank }
+      end
+
+      context 'and is a string' do
+        let(:options) { { deprecated: 'Some description' } }
+
+        it { is_expected.to be_an_instance_of(Apipie::ParamDescription::Deprecation) }
+      end
+
+      context 'and deprecation options are given' do
+        let(:options) do
+          { deprecated: { in: '2.3', info: 'Something', sunset: '3.0' } }
+        end
+
+        it { is_expected.to be_an_instance_of(Apipie::ParamDescription::Deprecation) }
+      end
+    end
+  end
+
+  describe '#required' do
+    subject { param_description.required }
+
+    let(:param_description) do
+      Apipie::ParamDescription.new(method_desc, :param, validator, options)
+    end
+
+    context 'when is passed in options' do
+      let(:validator) { String }
+
+      context 'when is false' do
+        let(:options) { { required: false } }
+
+        it { is_expected.to eq(false) }
+      end
+
+      context 'when is true' do
+        let(:options) { { required: true } }
+
+        it { is_expected.to eq(true) }
+      end
+    end
+
+    context 'when validator options are passed' do
+      let(:options) { { only_in: :response } }
+      let(:validator) { { array_of: String, required: required } }
+
+      context 'when required is false' do
+        let(:required) { false }
+
+        it { is_expected.to eq(false) }
+      end
+
+      context 'when required is true' do
+        let(:required) { true }
+
+        it { is_expected.to eq(true) }
+      end
+    end
+  end
 end

data/spec/lib/{param_group_spec.rb → apipie/param_group_spec.rb}

@@ -1,6 +1,7 @@
 require "spec_helper"
 
 describe "param groups" do
+  before { Apipie.reload_documentation }
 
   it "lets reuse the params description in more actions" do
     user_create_desc = Apipie["users#create"].params[:user]
@@ -43,17 +44,17 @@ describe "param groups" do
   end
 
   it "should replace parameter name in a group when it comes from concern" do
-    expect(Apipie["overridden_concern_resources#update"].params.has_key?(:user)).to eq(true)
+    expect(Apipie["overridden_concern_resources#update"].params.key?(:user)).to eq(true)
   end
 
   it "shouldn't replace parameter name in a group redefined in the controller" do
-    expect(Apipie["overridden_concern_resources#create"].params.has_key?(:concern)).to eq(true)
-    expect(Apipie["overridden_concern_resources#create"].params.has_key?(:user)).to eq(false)
+    expect(Apipie["overridden_concern_resources#create"].params.key?(:concern)).to eq(true)
+    expect(Apipie["overridden_concern_resources#create"].params.key?(:user)).to eq(false)
   end
 
 it "shouldn't replace name of a parameter defined in the controller" do
-    expect(Apipie["overridden_concern_resources#custom"].params.has_key?(:concern)).to eq(true)
-    expect(Apipie["overridden_concern_resources#custom"].params.has_key?(:user)).to eq(false)
+    expect(Apipie["overridden_concern_resources#custom"].params.key?(:concern)).to eq(true)
+    expect(Apipie["overridden_concern_resources#custom"].params.key?(:user)).to eq(false)
   end
 
 end