apipie-rails 0.3.6 → 0.9.1

data/spec/controllers/users_controller_spec.rb

@@ -51,7 +51,7 @@ describe UsersController do
       expect(subject._params_args.count).to eq(2)
       name, type, options = subject._params_args.first
       expect(name).to eq(:id)
-      expect(type).to eq(Fixnum)
+      expect(type).to eq(Integer)
       expect(options).to eq({:required=>false, :desc=>"User ID"})
     end
   end
@@ -66,12 +66,12 @@ describe UsersController do
       end
 
       it "should reply to valid request" do
-        get :show, :id => '5', :session => "secret_hash"
+        get :show, :params => { :id => '5', :session => "secret_hash" }
         assert_response :success
       end
 
       it "should pass if required parameter is missing" do
-        expect { get :show, :id => 5 }.not_to raise_error
+        expect { get :show, :params => { :id => 5 } }.not_to raise_error
       end
 
     end
@@ -92,17 +92,17 @@ describe UsersController do
           end
 
           it "should reply to valid request" do
-            expect { get :show, :id => 5, :session => "secret_hash" }.not_to raise_error
+            expect { get :show, :params => { :id => 5, :session => "secret_hash" }}.not_to raise_error
             assert_response :success
           end
 
           it "should fail if required parameter is missing" do
-            expect { get :show, :id => 5 }.to raise_error(Apipie::ParamMissing, /session_parameter_is_required/)
+            expect { get :show, :params => { :id => 5 }}.to raise_error(Apipie::ParamMissing, /session_parameter_is_required/)
           end
 
           it "should pass if required parameter has wrong type" do
-            expect { get :show, :id => 5, :session => "secret_hash" }.not_to raise_error
-            expect { get :show, :id => "ten", :session => "secret_hash" }.not_to raise_error
+            expect { get :show, :params => { :id => 5 , :session => "secret_hash" }}.not_to raise_error
+            expect { get :show, :params => { :id => "ten" , :session => "secret_hash" }}.not_to raise_error
           end
 
         end
@@ -115,12 +115,35 @@ describe UsersController do
           end
 
           it "should reply to valid request" do
-            expect { get :show, :id => 5, :session => "secret_hash" }.not_to raise_error
+            expect { get :show, :params => { :id => 5, :session => 'secret_hash' }}.not_to raise_error
             assert_response :success
           end
 
           it "should fail if extra parameter is passed in" do
-            expect { get :show, :id => 5, :session => "secret_hash", :badparam => 'badfoo' }.to raise_error(Apipie::UnknownParam, /\bbadparam\b/)
+            expect { get :show, :params => { :id => 5 , :badparam => 'badfoo', :session => "secret_hash" }}.to raise_error(Apipie::UnknownParam, /\bbadparam\b/)
+          end
+        end
+
+        context "key validations are enabled and skip on non-validated keys" do
+          before do
+            Apipie.configuration.validate_value = false
+            Apipie.configuration.validate_presence = true
+            Apipie.configuration.validate_key = true
+            Apipie.configuration.action_on_non_validated_keys = :skip
+          end
+
+          it "should reply to valid request" do
+            expect { get :show, :params => { :id => 5, :session => 'secret_hash' }}.not_to raise_error
+            assert_response :success
+          end
+
+          it "should delete the param and not fail if an extra parameter is passed." do
+            expect { get :show, :params => { :id => 5 , :badparam => 'badfoo', :session => "secret_hash" }}.not_to raise_error
+            expect(controller.params.as_json).to eq({"session"=>"secret_hash", "id"=>"5", "controller"=>"users", "action"=>"show"})
+          end
+
+          after do
+            Apipie.configuration.action_on_non_validated_keys = :raise
           end
         end
 
@@ -132,86 +155,80 @@ describe UsersController do
           end
 
           it "should reply to valid request" do
-            get :show, :id => '5', :session => "secret_hash"
+            get :show, :params => { :id => '5', :session => "secret_hash" }
             assert_response :success
           end
 
           it "should work with nil value for a required hash param" do
             expect {
-              get :show, :id => '5', :session => "secret_hash", :hash_param => {:dummy_hash => nil}
+              get :show, :params => { :id => '5', :session => "secret_hash", :hash_param => {:dummy_hash => nil} }
             }.to raise_error(Apipie::ParamInvalid, /dummy_hash/)
             assert_response :success
           end
 
           it "should fail if required parameter is missing" do
-            expect { get :show, :id => 5 }.to raise_error(Apipie::ParamMissing, /session_parameter_is_required/)
+            expect { get :show, :params => { :id => 5 }}.to raise_error(Apipie::ParamMissing, /session_parameter_is_required/)
           end
 
           it "should work with custom Type validator" do
             expect {
               get :show,
-                  :id => "not a number",
-                  :session => "secret_hash"
+                  :params => { :id => "not a number", :session => "secret_hash" }
             }.to raise_error(Apipie::ParamError, /id/) # old-style error rather than ParamInvalid
           end
 
           it "should work with Regexp validator" do
-            get :show,
-                :id => 5,
-                :session => "secret_hash",
-                :regexp_param => "24 years"
+            get :show, :params => { :id => 5, :session => "secret_hash", :regexp_param => "24 years" }
             assert_response :success
 
             expect {
-              get :show,
-                  :id => 5,
-                  :session => "secret_hash",
-                  :regexp_param => "ten years"
+              get :show, :params => { :id => 5,
+                                      :session => "secret_hash",
+                                      :regexp_param => "ten years" }
             }.to raise_error(Apipie::ParamInvalid, /regexp_param/)
           end
 
           it "should work with Array validator" do
-            get :show, :id => 5, :session => "secret_hash", :array_param => "one"
-            assert_response :success
-            get :show, :id => 5, :session => "secret_hash", :array_param => "two"
+            get :show, :params => { :id => 5, :session => "secret_hash", :array_param => "one" }
             assert_response :success
-            get :show, :id => 5, :session => "secret_hash", :array_param => '1'
+            get :show, :params => { :id => 5, :session => "secret_hash", :array_param => "two" }
             assert_response :success
-            get :show, :id => 5, :session => "secret_hash", :boolean_param => false
+            get :show, :params => { :id => 5, :session => "secret_hash", :array_param => '1' }
             assert_response :success
 
             expect {
-              get :show,
-                  :id => 5,
-                  :session => "secret_hash",
-                  :array_param => "blabla"
+              get :show, :params => { :id => 5,
+                                      :session => "secret_hash",
+                                      :array_param => "blabla" }
             }.to raise_error(Apipie::ParamInvalid, /array_param/)
 
             expect {
-              get :show,
-                  :id => 5,
-                  :session => "secret_hash",
-                  :array_param => 3
+              get :show, :params => {
+                :id => 5,
+                :session => "secret_hash",
+                :array_param => 3 }
             }.to raise_error(Apipie::ParamInvalid, /array_param/)
           end
 
           it "should work with Proc validator" do
             expect {
               get :show,
-                  :id => 5,
-                  :session => "secret_hash",
-                  :proc_param => "asdgsag"
+                  :params => {
+                    :id => 5,
+                    :session => "secret_hash",
+                    :proc_param => "asdgsag" }
             }.to raise_error(Apipie::ParamInvalid, /proc_param/)
 
             get :show,
-                :id => 5,
-                :session => "secret_hash",
-                :proc_param => "param value"
+                :params => {
+                  :id => 5,
+                  :session => "secret_hash",
+                  :proc_param => "param value"}
             assert_response :success
           end
 
           it "should work with Hash validator" do
-            post :create, :user => { :name => "root", :pass => "12345", :membership => "standard" }
+            post :create, params: { :user => { :name => "root", :pass => "12345", :membership => "standard" } }
             assert_response :success
 
             a = Apipie[UsersController, :create]
@@ -225,18 +242,18 @@ describe UsersController do
             hash_params[2].name == :membership
 
             expect {
-              post :create, :user => { :name => "root", :pass => "12345", :membership => "____" }
+              post :create, :params => { :user => { :name => "root", :pass => "12345", :membership => "____" } }
             }.to raise_error(Apipie::ParamInvalid, /membership/)
 
             expect {
-              post :create, :user => { :name => "root" }
+              post :create, :params => { :user => { :name => "root" } }
             }.to raise_error(Apipie::ParamMissing, /pass/)
 
             expect {
-              post :create, :user => "a string is not a hash"
+              post :create, :params => { :user => "a string is not a hash" }
             }.to raise_error(Apipie::ParamInvalid, /user/)
 
-            post :create, :user => { :name => "root", :pass => "pwd" }
+            post :create, :params => { :user => { :name => "root", :pass => "pwd" } }
             assert_response :success
           end
 
@@ -244,10 +261,11 @@ describe UsersController do
             params = Apipie[UsersController, :create].to_json[:params]
             expect(params).to include(:name => "facts",
                                   :full_name => "facts",
-                                  :validator => "Must be Hash",
+                                  :validator => "Must be a Hash",
                                   :description => "\n<p>Additional optional facts about the user</p>\n",
                                   :required => false,
                                   :allow_nil => true,
+                                  :allow_blank => false,
                                   :metadata => nil,
                                   :show => true,
                                   :expected_type => "hash",
@@ -256,12 +274,27 @@ describe UsersController do
 
           it "should allow nil when allow_nil is set to true" do
             post :create,
-                 :user => {
-                   :name => "root",
-                   :pass => "12345",
-                   :membership => "standard",
-                 },
-                 :facts => nil
+                 :params => {
+                   :user => {
+                     :name => "root",
+                     :pass => "12345",
+                     :membership => "standard",
+                   },
+                   :facts => { :test => 'test' }
+                 }
+            assert_response :success
+          end
+
+          it "should allow blank when allow_blank is set to true" do
+            post :create,
+              :params => {
+                :user => {
+                  :name => "root",
+                  :pass => "12345",
+                  :membership => "standard"
+                },
+                :age => ""
+              }
             assert_response :success
           end
 
@@ -270,7 +303,7 @@ describe UsersController do
             context "with valid input" do
               it "should succeed" do
                 put :update,
-                    {
+                    :params => {
                       :id => 5,
                       :user => {
                         :name => "root",
@@ -293,27 +326,27 @@ describe UsersController do
               it "should raise an error" do
                 expect{
                   put :update,
-                    {
-                      :id => 5,
-                      :user => {
-                        :name => "root",
-                        :pass => "12345"
-                      },
-                      :comments => [
-                        {
-                          :comment => 'comment1'
+                      :params => {
+                        :id => 5,
+                        :user => {
+                          :name => "root",
+                          :pass => "12345"
                         },
-                        {
-                          :comment => {:bad_input => 5}
-                        }
-                      ]
-                    }
+                        :comments => [
+                          {
+                            :comment => {:bad_input => 4}
+                          },
+                          {
+                            :comment => {:bad_input => 5}
+                          }
+                        ]
+                      }
                 }.to raise_error(Apipie::ParamInvalid)
               end
             end
             it "should work with empty array" do
               put :update,
-                  {
+                  :params => {
                     :id => 5,
                     :user => {
                       :name => "root",
@@ -441,6 +474,14 @@ describe UsersController do
       expect(a.errors[2].description).to eq("Not Found")
     end
 
+    it 'should recognize Rack symbols as error codes' do
+      a = Apipie.get_method_description(UsersController, :create)
+
+      error = a.errors.find { |e| e.code == 422 }
+      expect(error).to be
+      expect(error.description).to include("Unprocessable Entity")
+    end
+
     it "should contain all params description" do
       a = Apipie.get_method_description(UsersController, :show)
       expect(a.params.count).to eq(12)
@@ -464,7 +505,19 @@ describe UsersController do
             name: :OptionalHeaderName,
             description: 'Optional header description',
             options: {
-              required: false
+              required: false,
+              type: "string"
+            }
+          }
+        end
+
+        let(:expected_header_with_default) do
+          {
+            name: :HeaderNameWithDefaultValue,
+            description: 'Header with default value',
+            options: {
+              required: true,
+              default: 'default value'
             }
           }
         end
@@ -475,6 +528,7 @@ describe UsersController do
 
           compare_hashes headers[0], expected_required_header
           compare_hashes headers[1], expected_optional_header
+          compare_hashes headers[2], expected_header_with_default
         end
       end
 
@@ -525,7 +579,8 @@ describe UsersController do
         :params => [{:full_name=>"oauth",
                      :required=>false,
                      :allow_nil => false,
-                     :validator=>"Must be String",
+                     :allow_blank => false,
+                     :validator=>"Must be a String",
                      :description=>"\n<p>Authorization</p>\n",
                      :name=>"oauth",
                      :show=>true,
@@ -534,6 +589,7 @@ describe UsersController do
                      :description=>"\n<p>Deprecated parameter not documented</p>\n",
                      :expected_type=>"hash",
                      :allow_nil=>false,
+                     :allow_blank => false,
                      :name=>"legacy_param",
                      :required=>false,
                      :full_name=>"legacy_param",
@@ -543,6 +599,7 @@ describe UsersController do
                         :description=>"\n<p>Param description for all methods</p>\n",
                         :expected_type=>"hash",
                         :allow_nil=>false,
+                       :allow_blank => false,
                         :name=>"resource_param",
                         :required=>false,
                         :full_name=>"resource_param",
@@ -550,14 +607,16 @@ describe UsersController do
                         :params=>
                         [{:required=>true,
                           :allow_nil => false,
-                          :validator=>"Must be String",
+                          :allow_blank => false,
+                          :validator=>"Must be a String",
                           :description=>"\n<p>Username for login</p>\n",
                           :name=>"ausername", :full_name=>"resource_param[ausername]",
                           :show=>true,
                           :expected_type=>"string"},
                          {:required=>true,
                           :allow_nil => false,
-                          :validator=>"Must be String",
+                          :allow_blank => false,
+                          :validator=>"Must be a String",
                           :description=>"\n<p>Password for login</p>\n",
                           :name=>"apassword", :full_name=>"resource_param[apassword]",
                           :show=>true,
@@ -567,6 +626,7 @@ describe UsersController do
                     },
                     {:required=>false, :validator=>"Parameter has to be Integer.",
                      :allow_nil => false,
+                     :allow_blank => false,
                      :description=>"\n<p>Company ID</p>\n",
                      :name=>"id", :full_name=>"id",
                      :show=>true,
@@ -690,17 +750,20 @@ EOS2
 
   describe "Parameter processing / extraction" do
     before do
+      Apipie.configuration.validate = true
       Apipie.configuration.process_params = true
+      controllers_dirname = File.expand_path('../dummy/app/controllers', File.dirname(__FILE__))
+      Dir.glob("#{controllers_dirname}/**/*") { |file| load(file) if File.file?(file) }
     end
 
     it "process correctly the parameters" do
-      post :create, {:user => {:name => 'dummy', :pass => 'dummy', :membership => 'standard'}, :facts => nil}
+      post :create, :params => {:user => {:name => 'dummy', :pass => 'dummy', :membership => 'standard' }, :facts => {:test => 'test'}}
 
-      expect(assigns(:api_params).with_indifferent_access).to eq({:user => {:name=>"dummy", :pass=>"dummy", :membership=>"standard"}, :facts => nil}.with_indifferent_access)
+      expect(assigns(:api_params).with_indifferent_access).to eq({:user => {:name=>"dummy", :pass=>"dummy", :membership=>"standard"}, :facts => {:test => 'test'}}.with_indifferent_access)
     end
 
     it "ignore not described parameters" do
-      post :create, {:user => {:name => 'dummy', :pass => 'dummy', :membership => 'standard', :id => 0}}
+      post :create, :params => {:user => {:name => 'dummy', :pass => 'dummy', :membership => 'standard', :id => 0}}
 
       expect(assigns(:api_params).with_indifferent_access).to eq({:user => {:name=>"dummy", :pass=>"dummy", :membership=>"standard"}}.with_indifferent_access)
     end

data/spec/dummy/Rakefile

@@ -1,7 +1,7 @@
 # Add your own tasks in files placed in lib/tasks ending in .rake,
 # for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
 
-require File.expand_path('../config/application', __FILE__)
+require File.expand_path('config/application', __dir__)
 require 'rake'
 
 Dummy::Application.load_tasks

data/spec/dummy/app/controllers/application_controller.rb

@@ -1,8 +1,12 @@
 class ApplicationController < ActionController::Base
-  before_filter :run_validations
+  before_action :run_validations
   
   resource_description do
     param :oauth, String, :desc => "Authorization", :required => false
+
+    returns :code => 401 do
+      property :reason, String, "Why authorization was denied"
+    end
   end
 
   def run_validations

data/spec/dummy/app/controllers/concerns_controller.rb

@@ -3,6 +3,6 @@ class ConcernsController < ApplicationController
   resource_description { resource_id 'concern_resources' }
 
   apipie_concern_subst(:concern => 'user', :custom_subst => 'custom', 'string_subst' => 'string')
-  include ::Concerns::SampleController
+  include SampleController
 
 end

data/spec/dummy/app/controllers/extended_controller.rb

@@ -0,0 +1,14 @@
+class ExtendedController < ApplicationController
+
+  api :POST, '/extended'
+  param :user, Hash do
+    param :name, String
+    param :password, String
+  end
+  def create
+  end
+
+  apipie_update_params([:create]) do
+    param :admin, :boolean
+  end
+end

data/spec/dummy/app/controllers/extending_concern.rb

@@ -0,0 +1,10 @@
+  module ExtendingConcern
+    extend Apipie::DSL::Concern
+
+    update_api(:create) do
+      param :user, Hash do
+        param :from_concern, String, :desc => 'param from concern', :allow_nil => false
+      end
+      meta metadata: 'data'
+    end
+  end

data/spec/dummy/app/controllers/included_param_group_controller.rb

@@ -0,0 +1,19 @@
+class IncludedParamGroupController < ApplicationController
+  include RandomParamGroup
+
+  api :GET, '/included-param-group'
+  returns code:200 do
+    property :top_level, Array, of: Hash do
+      param_group :random_param_group
+    end
+    property :nested, Hash do
+      property :random_array, Array, of: Hash do
+        param_group :random_param_group
+      end
+    end
+  end
+  def show
+  end
+
+end
+

data/spec/dummy/app/controllers/overridden_concerns_controller.rb

@@ -3,7 +3,7 @@ class OverriddenConcernsController < ApplicationController
   resource_description { resource_id 'overridden_concern_resources' }
 
   apipie_concern_subst(:concern => 'user')
-  include ::Concerns::SampleController
+  include SampleController
 
   def_param_group :concern do
     param :concern, String
@@ -11,7 +11,7 @@ class OverriddenConcernsController < ApplicationController
 
   api :PUT, '/:resource_id/:id'
   param :custom_parameter, String, "New parameter added by the overriding method"
-  param_group :concern, ::Concerns::SampleController
+  param_group :concern, SampleController
   def update
     super
   end