apipie-rails 0.9.3 → 1.0.0

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

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_spec.rb

@@ -114,88 +114,210 @@ 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 do
-        Apipie.configuration.ignore_allow_blank_false = true
-      end
+      before { Apipie.configuration.ignore_allow_blank_false = true }
+      after { Apipie.configuration.ignore_allow_blank_false = false }
 
-      context 'when the parameter is a boolean' do
-        it "should not throw an exception when passed false" do
-          expect { Apipie::ParamDescription.new(method_desc, :param, :boolean).validate(false) }.to_not raise_error
+      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
 
-        it "should throw an exception when passed an empty value" do
-          expect { Apipie::ParamDescription.new(method_desc, :param, :boolean).validate('') }.to raise_error(Apipie::ParamInvalid)
+        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 parameter is a string' do
-        context 'when allow_blank is specified as true' do
-          it "should throw an exception when passed an empty value" do
-            expect { Apipie::ParamDescription.new(method_desc, :param, String, allow_blank: true).validate('') }.to_not raise_error
+      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 allow_blank is specified as false' do
-          it "should throw an exception when passed an empty value" do
-            expect { Apipie::ParamDescription.new(method_desc, :param, String, allow_blank: false).validate('') }.to_not raise_error
+
+        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 allow_blank is not specified' do
-          it "should throw an exception when passed an empty value" do
-            expect { Apipie::ParamDescription.new(method_desc, :param, String).validate('') }.to_not raise_error
+
+        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
 
-      after do
-        Apipie.configuration.ignore_allow_blank_false = false
+      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 parameter is a boolean' do
-      it "should not throw an exception when passed false" do
-        expect { Apipie::ParamDescription.new(method_desc, :param, :boolean).validate(false) }.to_not raise_error
-      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 still not throw an exception when passed false with explicit allow_blank: false" do
-        expect { Apipie::ParamDescription.new(method_desc, :param, :boolean, allow_blank: false).validate(false) }.to_not raise_error
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
+          end
+        end
       end
 
-      it "should throw an exception when passed an empty value" do
-        expect { Apipie::ParamDescription.new(method_desc, :param, :boolean).validate('') }.to raise_error(Apipie::ParamInvalid)
+      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 the parameter is a custom type with ignore_allow_blank? returning true" do
-      it "should not throw an exception when passed a blank but valid value" do
-        expect { Apipie::ParamDescription.new(method_desc, :param, :custom_bool).validate(false) }.to_not raise_error
+    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
 
-      it "should still not throw an exception when passed false with explicit allow_blank: false" do
-        expect { Apipie::ParamDescription.new(method_desc, :param, :custom_bool, allow_blank: false).validate(false) }.to_not raise_error
+      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
 
-      it "should throw an exception when passed an invalid but blank value" do
-        expect { Apipie::ParamDescription.new(method_desc, :param, :custom_bool).validate("") }.to raise_error(Apipie::ParamInvalid)
+      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 parameter is a string' do
-      context 'when allow_blank is specified as true' do
-        it "should throw an exception when passed an empty value" do
-          expect { Apipie::ParamDescription.new(method_desc, :param, String, allow_blank: true).validate('') }.to_not raise_error
+    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
-      context 'when allow_blank is specified as false' do
-        it "should throw an exception when passed an empty value" do
-          expect do
-            Apipie::ParamDescription.new(method_desc, :param, String, allow_blank: false).validate('')
-          end.to raise_error(Apipie::ParamInvalid)
+    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 not specified' do
-        it "should throw an exception when passed an empty value" do
-          expect { Apipie::ParamDescription.new(method_desc, :param, String).validate('') }.to raise_error(Apipie::ParamInvalid)
+
+      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
@@ -239,7 +361,6 @@ describe Apipie::ParamDescription do
     end
   end
 
-
   describe "required_by_default config option" do
     context "parameters required by default" do
 
@@ -369,7 +490,6 @@ describe Apipie::ParamDescription do
     end
   end
 
-
   describe 'sub params' do
 
     context 'with HashValidator' do
@@ -508,4 +628,44 @@ describe Apipie::ParamDescription do
     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/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]

data/spec/lib/apipie/resource_description_spec.rb

@@ -1,48 +1,91 @@
 require "spec_helper"
 
 describe Apipie::ResourceDescription do
+  let(:resource_description) do
+    Apipie::ResourceDescription.new(controller, id, dsl_data)
+  end
 
+  let(:controller) { ApplicationController }
+  let(:id) { 'dummy' }
   let(:dsl_data) { ActionController::Base.send(:_apipie_dsl_data_init) }
 
-  describe "metadata" do
+  describe '#_methods' do
+    subject(:methods) { resource_description._methods }
 
-    it "should return nil when no metadata is provided" do
-      resource = Apipie::ResourceDescription.new(ApplicationController, "dummy", dsl_data)
-      expect(resource.to_json[:metadata]).to eq(nil)
-    end
+    context 'when has method descriptions' do
+      before do
+        resource_description.add_method_description(
+          Apipie::MethodDescription.new(:a, resource_description, dsl_data)
+        )
+        resource_description.add_method_description(
+          Apipie::MethodDescription.new(:b, resource_description, dsl_data)
+        )
+        resource_description.add_method_description(
+          Apipie::MethodDescription.new(:c, resource_description, dsl_data)
+        )
+      end
 
-    it "should return the metadata" do
-      meta = {
-        :lenght => 32,
-        :weight => '830g'
-      }
-      resource = Apipie::ResourceDescription.new(ApplicationController, "dummy", dsl_data.update(:meta => meta))
-      expect(resource.to_json[:metadata]).to eq(meta)
+      it 'should be ordered' do
+        expect(methods.keys).to eq([:a, :b, :c])
+      end
     end
-
   end
 
-  describe "methods descriptions" do
+  describe '#to_json' do
+    let(:json_data) { resource_description.to_json }
+
+    describe 'metadata' do
+      subject { json_data[:metadata] }
 
-    before(:each) do
-      @resource = Apipie::ResourceDescription.new(ApplicationController, "dummy")
-      a = Apipie::MethodDescription.new(:a, @resource, dsl_data)
-      b = Apipie::MethodDescription.new(:b, @resource, dsl_data)
-      c = Apipie::MethodDescription.new(:c, @resource, dsl_data)
-      @resource.add_method_description(a)
-      @resource.add_method_description(b)
-      @resource.add_method_description(c)
+      it { is_expected.to be_nil }
+
+      context 'when meta data are provided' do
+        let(:meta) { { length: 32, weight: '830g' } }
+        let(:dsl_data) { super().update({ meta: meta }) }
+
+        it { is_expected.to eq(meta) }
+      end
     end
 
-    it "should be ordered" do
-      expect(@resource._methods.keys).to eq([:a, :b, :c])
-      expect(@resource.to_json[:methods].map { |h| h[:name] }).to eq(['a', 'b', 'c'])
+    describe 'methods' do
+      subject(:methods_as_json) { json_data[:methods] }
+
+      context 'when has method descriptions' do
+        before do
+          resource_description.add_method_description(
+            Apipie::MethodDescription.new(:a, resource_description, dsl_data)
+          )
+          resource_description.add_method_description(
+            Apipie::MethodDescription.new(:b, resource_description, dsl_data)
+          )
+          resource_description.add_method_description(
+            Apipie::MethodDescription.new(:c, resource_description, dsl_data)
+          )
+        end
+
+        it 'should be ordered' do
+          expect(methods_as_json.map { |h| h[:name] }).to eq(%w[a b c])
+        end
+      end
     end
+  end
+
+  describe 'name' do
+    subject { resource_description.name }
+
+    it { is_expected.to eq('Dummy') }
 
-    it "should be still ordered" do
-      expect(@resource._methods.keys).to eq([:a, :b, :c])
-      expect(@resource.to_json[:methods].map { |h| h[:name] }).to eq(['a', 'b', 'c'])
+    context 'when given id contains dashes' do
+      let(:id) { 'some-nested-resource' }
+
+      it { is_expected.to eq('Some::Nested::Resource') }
     end
 
+    context 'when resource_name is given' do
+      let(:resource_name) { 'Some-Resource' }
+      let(:dsl_data) { super().merge!(resource_name: 'Some-Resource') }
+
+      it { is_expected.to eq(resource_name) }
+    end
   end
 end