apipie-rails 0.3.5 → 0.3.6

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

@@ -174,8 +174,9 @@ class UsersController < ApplicationController
   error 401, "Unauthorized"
   error :code => 404, :description => "Not Found"
   param :id, Integer, :desc => "user id", :required => true
-  param :session, String, :desc => "user is logged in", :required => true
+  param :session, String, :desc => "user is logged in", :required => true, :missing_message => lambda { "session_parameter_is_required" }
   param :regexp_param, /^[0-9]* years/, :desc => "regexp param"
+  param :regexp2, /\b[A-Z0-9._%+-=]+@[A-Z0-9.-]+.[A-Z]{2,}\b/i, :desc => "email regexp"
   param :array_param, ["100", "one", "two", "1", "2"], :desc => "array validator"
   param :boolean_param, [true, false], :desc => "array validator with boolean"
   param :proc_param, lambda { |val|

data/spec/dummy/config/initializers/secret_token.rb

@@ -5,3 +5,4 @@
 # Make sure the secret is at least 30 characters and all random,
 # no regular words or you'll be exposed to dictionary attacks.
 Dummy::Application.config.secret_token = '431a859f504c40942b0caa3a740492b8bfd87c7898db4b1c39557f440f1cdda99c54810ad81f6ba7e1cece75bc079caa52a5cb54dbd085effd038ba283b837ce'
+Dummy::Application.config.secret_key_base = '431a859f504c40942b0caa3a740492b8bfd87c7898db4b1c39557f440f1cdda99c54810ad81f6ba7e1cece75bc079caa52a5cb54dbd085effd038ba283b837ce'

data/spec/lib/application_spec.rb

@@ -21,13 +21,13 @@ describe Apipie::Application do
       context "with a defined base url" do
         
         it "should not overwrite the parent resource" do
-          should_not eq(Apipie.get_resource_name(Api::V2::ArchitecturesController))
+          is_expected.not_to eq(Apipie.get_resource_name(Api::V2::ArchitecturesController))
         end
         
       end
 
       context "with an undefined base url" do
-        before {Apipie.app.stub(:get_base_url) { nil }}
+        before {allow(Apipie.app).to receive(:get_base_url) { nil }}
 
         it "should not raise an error" do
           expect { Apipie.get_resource_name(Api::V2::ArchitecturesController) }.
@@ -42,7 +42,7 @@ describe Apipie::Application do
       before { Apipie.configuration.namespaced_resources = false }
 
       it "should overwrite the the parent" do
-        should eq(Apipie.get_resource_name(Api::V2::ArchitecturesController))
+        is_expected.to eq(Apipie.get_resource_name(Api::V2::ArchitecturesController))
       end
     end
   end

data/spec/lib/extractor/writer_spec.rb

@@ -60,19 +60,19 @@ describe Apipie::Extractor::Writer do
   describe "with doc_path overriden in configuration" do
     it "should use the doc_path specified in configuration" do
       Apipie.configuration.doc_path = "user_specified_doc_path"
-      writer_class.examples_file.should eq(File.join(Rails.root, "user_specified_doc_path", "apipie_examples.json"))
+      expect(writer_class.examples_file).to eql(File.join(Rails.root, "user_specified_doc_path", "apipie_examples.json"))
     end
   end
 
   describe "storing of examples" do
     before do
-      writer_class.stub(:examples_file) { test_examples_file }
-      collector.should_receive(:records).and_return(records)
+      allow(writer_class).to receive(:examples_file) { test_examples_file }
+      expect(collector).to receive(:records).and_return(records)
     end
 
     it "should read and write examples" do
       writer.write_examples
-      writer.send(:load_recorded_examples).should eq(loaded_records)
+      expect(writer.send(:load_recorded_examples)).to eql(loaded_records)
     end
 
     after do

data/spec/lib/method_description_spec.rb

@@ -12,7 +12,7 @@ describe Apipie::MethodDescription do
 
     it "should return nil when no metadata is provided" do
       method = Apipie::MethodDescription.new(:a, @resource, dsl_data)
-      method.to_json[:metadata].should == nil
+      expect(method.to_json[:metadata]).to eq(nil)
     end
 
     it "should return the metadata" do
@@ -21,7 +21,7 @@ describe Apipie::MethodDescription do
         :weight => '830g'
       }
       method = Apipie::MethodDescription.new(:a, @resource, dsl_data.update(:meta => meta))
-      method.to_json[:metadata].should == meta
+      expect(method.to_json[:metadata]).to eq(meta)
     end
 
   end
@@ -34,7 +34,7 @@ describe Apipie::MethodDescription do
     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)
-      method.method_apis_to_json.first[:deprecated].should == true
+      expect(method.method_apis_to_json.first[:deprecated]).to eq(true)
     end
   end
 
@@ -50,13 +50,13 @@ describe Apipie::MethodDescription do
     end
 
     it "should be ordered" do
-      @method.params.keys.should == [:a, :b, :c]
-      @method.to_json[:params].map{|h| h[:name]}.should == ['a', 'b', 'c']
+      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 "should be still ordered" do
-      @method.params.keys.should == [:a, :b, :c]
-      @method.to_json[:params].map{|h| h[:name]}.should == ['a', 'b', 'c']
+      expect(@method.params.keys).to eq([:a, :b, :c])
+      expect(@method.to_json[:params].map{|h| h[:name]}).to eq(['a', 'b', 'c'])
     end
 
   end

data/spec/lib/param_description_spec.rb

@@ -16,7 +16,7 @@ describe Apipie::ParamDescription do
 
     it "should return nil when no metadata is provided" do
       param = Apipie::ParamDescription.new(method_desc, :some_param, String)
-      param.to_json[:metadata].should == nil
+      expect(param.to_json[:metadata]).to eq(nil)
     end
 
     it "should return the metadata" do
@@ -25,7 +25,7 @@ describe Apipie::ParamDescription do
         :weight => '830g'
       }
       param = Apipie::ParamDescription.new(method_desc, :some_param, String, :meta => meta)
-      param.to_json[:metadata].should == meta
+      expect(param.to_json[:metadata]).to eq(meta)
     end
 
   end
@@ -34,15 +34,15 @@ describe Apipie::ParamDescription do
 
     it "should return true when show option is not provided" do
       param = Apipie::ParamDescription.new(method_desc, :some_param, String)
-      param.to_json[:show].should == true
+      expect(param.to_json[:show]).to eq(true)
     end
 
     it "should return the show option" do
       param = Apipie::ParamDescription.new(method_desc, :some_param, String, :show => true)
-      param.to_json[:show].should == true
+      expect(param.to_json[:show]).to eq(true)
 
       param = Apipie::ParamDescription.new(method_desc, :some_param, String, :show => false)
-      param.to_json[:show].should == false
+      expect(param.to_json[:show]).to eq(false)
     end
 
   end
@@ -52,7 +52,7 @@ describe Apipie::ParamDescription do
 
       it "should return name" do
         param = Apipie::ParamDescription.new(method_desc, :some_param, String)
-        param.to_json[:full_name].should == 'some_param'
+        expect(param.to_json[:full_name]).to eq('some_param')
       end
 
     end
@@ -63,7 +63,7 @@ describe Apipie::ParamDescription do
         parent_param = Apipie::ParamDescription.new(method_desc, :parent, String)
         nested_param = Apipie::ParamDescription.new(method_desc, :nested, String, :parent => parent_param)
 
-        nested_param.to_json[:full_name].should == 'parent[nested]'
+        expect(nested_param.to_json[:full_name]).to eq('parent[nested]')
       end
 
       context "with the parent parameter set to not show" do
@@ -72,28 +72,43 @@ describe Apipie::ParamDescription do
           parent_param = Apipie::ParamDescription.new(method_desc, :parent, String, :show => false)
           nested_param = Apipie::ParamDescription.new(method_desc, :nested, String, :parent => parent_param)
 
-          nested_param.to_json[:full_name].should == 'nested'
+          expect(nested_param.to_json[:full_name]).to eq('nested')
         end
 
       end
     end
   end
 
+  describe "manual validation text" do
+    it "should allow manual text" do
+      param = Apipie::ParamDescription.new(method_desc, :hidden_param, nil, :validations => "must be foo")
+
+      expect(param.validations).to include("\n<p>must be foo</p>\n")
+    end
+
+    it "should allow multiple items" do
+      param = Apipie::ParamDescription.new(method_desc, :hidden_param, nil, :validations => ["> 0", "< 5"])
+
+      expect(param.validations).to include("\n<p>&gt; 0</p>\n")
+      expect(param.validations).to include("\n<p>&lt; 5</p>\n")
+    end
+  end
+
   describe "validator selection" do
 
     it "should allow nil validator" do
       param = Apipie::ParamDescription.new(method_desc, :hidden_param, nil)
-      param.validator.should be_nil
+      expect(param.validator).to be_nil
     end
 
     it "should throw exception on unknown validator" do
-      proc { Apipie::ParamDescription.new(method_desc, :param, :unknown) }.should raise_error(RuntimeError, /Validator.*not found/)
+      expect { Apipie::ParamDescription.new(method_desc, :param, :unknown) }.to raise_error(RuntimeError, /Validator.*not found/)
     end
 
     it "should pick type validator" do
-      Apipie::Validator::BaseValidator.should_receive(:find).and_return(:validator_instance)
+      expect(Apipie::Validator::BaseValidator).to receive(:find).and_return(:validator_instance)
       param = Apipie::ParamDescription.new(method_desc, :param, String)
-      param.validator.should == :validator_instance
+      expect(param.validator).to eq(:validator_instance)
     end
 
   end
@@ -112,27 +127,27 @@ describe Apipie::ParamDescription do
 
     it "should replace string parameter name with colon prefix" do
       param = Apipie::ParamDescription.new(concern_method_desc, ":string_subst", String)
-      param.name.should == "string"
+      expect(param.name).to eq("string")
     end
 
     it "should replace symbol parameter name" do
       param = Apipie::ParamDescription.new(concern_method_desc, :concern, String)
-      param.name.should == :user
+      expect(param.name).to eq(:user)
     end
 
     it "should keep original value for strings without colon prefixes" do
       param = Apipie::ParamDescription.new(concern_method_desc, "string_subst", String)
-      param.name.should == "string_subst"
+      expect(param.name).to eq("string_subst")
     end
 
     it "should keep the original value when a string can't be replaced" do
       param = Apipie::ParamDescription.new(concern_method_desc, ":param", String)
-      param.name.should == ":param"
+      expect(param.name).to eq(":param")
     end
 
     it "should keep the original value when a symbol can't be replaced" do
       param = Apipie::ParamDescription.new(concern_method_desc, :param, String)
-      param.name.should == :param
+      expect(param.name).to eq(:param)
     end
   end
 
@@ -144,12 +159,12 @@ describe Apipie::ParamDescription do
 
       it "should set param as required by default" do
         param = Apipie::ParamDescription.new(method_desc, :required_by_default, String)
-        param.required.should be_true
+        expect(param.required).to be true
       end
 
       it "should be possible to set param as optional" do
         param = Apipie::ParamDescription.new(method_desc, :optional, String, :required => false)
-        param.required.should be_false
+        expect(param.required).to be false
       end
 
     end
@@ -160,12 +175,12 @@ describe Apipie::ParamDescription do
 
       it "should set param as optional by default" do
         param = Apipie::ParamDescription.new(method_desc, :optional_by_default, String)
-        param.required.should be_false
+        expect(param.required).to be false
       end
 
       it "should be possible to set param as required" do
         param = Apipie::ParamDescription.new(method_desc, :required, String, 'description','required' => true)
-        param.required.should be_true
+        expect(param.required).to be true
       end
 
     end
@@ -180,21 +195,21 @@ describe Apipie::ParamDescription do
     context "when the param is required for current action" do
       it "should set param as required" do
         param = Apipie::ParamDescription.new(method_desc, :required, String, 'description','required' => :create)
-        param.required.should be_true
+        expect(param.required).to be true
       end
     end
 
     context "when the param is required for multiple actions" do
       it "should set param as required if it match current action" do
         param = Apipie::ParamDescription.new(method_desc, :required, String, 'description','required' => [:update, :create])
-        param.required.should be_true
+        expect(param.required).to be true
       end
     end
 
     context "when the param is not required for current action" do
       it "should set param as not required" do
         param = Apipie::ParamDescription.new(method_desc, :required, String, 'description','required' => :update)
-        param.required.should be_false
+        expect(param.required).to be false
       end
     end
   end
@@ -218,13 +233,13 @@ describe Apipie::ParamDescription do
       end
 
       it "makes the param required" do
-        required.should include :name
-        required.should include :pass
+        expect(required).to include :name
+        expect(required).to include :pass
       end
 
       it "doesn't allow nil" do
-        allowed_nil.should_not include :name
-        allowed_nil.should_not include :pass
+        expect(allowed_nil).not_to include :name
+        expect(allowed_nil).not_to include :pass
       end
     end
 
@@ -235,17 +250,17 @@ describe Apipie::ParamDescription do
       end
 
       it "doesn't make the param required" do
-        required.should_not include :name
-        required.should_not include :pass
+        expect(required).not_to include :name
+        expect(required).not_to include :pass
       end
 
       it "doesn't allow nil" do
-        allowed_nil.should_not include :name
-        allowed_nil.should_not include :pass
+        expect(allowed_nil).not_to include :name
+        expect(allowed_nil).not_to include :pass
       end
 
       it "doesn't touch params with explicitly set allow_nil" do
-        allowed_nil.should_not include :membership
+        expect(allowed_nil).not_to include :membership
       end
     end
 
@@ -255,13 +270,13 @@ describe Apipie::ParamDescription do
       end
 
       it "makes the param required" do
-        required.should include :name
-        required.should include :pass
+        expect(required).to include :name
+        expect(required).to include :pass
       end
 
       it "doesn't allow nil" do
-        allowed_nil.should_not include :name
-        allowed_nil.should_not include :pass
+        expect(allowed_nil).not_to include :name
+        expect(allowed_nil).not_to include :pass
       end
     end
   end
@@ -279,10 +294,10 @@ describe Apipie::ParamDescription do
 
       it "should include the nested params in the json" do
         sub_params = subject.to_json[:params]
-        sub_params.size.should == 1
+        expect(sub_params.size).to eq(1)
         sub_param = sub_params.first
-        sub_param[:name].should == "answer"
-        sub_param[:full_name].should == "param[answer]"
+        expect(sub_param[:name]).to eq("answer")
+        expect(sub_param[:full_name]).to eq("param[answer]")
       end
 
     end
@@ -297,10 +312,10 @@ describe Apipie::ParamDescription do
 
       it "should include the nested params in the json" do
         sub_params = subject.to_json[:params]
-        sub_params.size.should == 1
+        expect(sub_params.size).to eq(1)
         sub_param = sub_params.first
-        sub_param[:name].should == "answer"
-        sub_param[:full_name].should == "param[answer]"
+        expect(sub_param[:name]).to eq("answer")
+        expect(sub_param[:full_name]).to eq("param[answer]")
       end
 
     end
@@ -312,7 +327,7 @@ describe Apipie::ParamDescription do
       end
 
       it "should include the nested params in the json" do
-        subject.to_json[:params].should be_nil
+        expect(subject.to_json[:params]).to be_nil
       end
 
     end
@@ -322,8 +337,8 @@ 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])
-      expect { param.validate("1") }.should_not raise_error
-      expect { param.validate(Fixnum) }.should raise_error
+      expect { param.validate("1") }.not_to raise_error
+      expect { param.validate(Fixnum) }.to raise_error(Apipie::ParamInvalid)
     end
   end
 

data/spec/lib/param_group_spec.rb

@@ -10,25 +10,25 @@ describe "param groups" do
     user_update_params = user_update_desc.validator.params_ordered.map(&:name)
 
     common = user_update_params & user_create_params
-    common.sort_by(&:to_s).should == user_update_params.sort_by(&:to_s)
+    expect(common.sort_by(&:to_s)).to eq(user_update_params.sort_by(&:to_s))
   end
 
   it "allows using groups is nested param descriptions" do
     user_create_desc = Apipie["users#update"].params[:user]
     user_create_params = user_create_desc.validator.params_ordered.map(&:name)
-    user_create_params.map(&:to_s).sort.should == %w[membership name pass]
+    expect(user_create_params.map(&:to_s).sort).to eq(%w[membership name pass])
   end
 
   it "should allow adding additional params to group" do
     user_create_desc = Apipie["users#create"].params[:user]
     user_create_params = user_create_desc.validator.params_ordered.map(&:name)
-    user_create_params.map(&:to_s).sort.should == %w[membership name pass permalink]
+    expect(user_create_params.map(&:to_s).sort).to eq(%w[membership name pass permalink])
   end
 
   context "hash param" do
     it "influences only its childs" do
-      Apipie["users#create"].params[:user].required.should be true
-      Apipie["users#update"].params[:user].required.should be true
+      expect(Apipie["users#create"].params[:user].required).to be true
+      expect(Apipie["users#update"].params[:user].required).to be true
     end
   end
 
@@ -39,21 +39,21 @@ describe "param groups" do
     arch_v2_desc = Apipie["2.0#architectures#create"].params[:architecture]
     arch_v2_params = arch_v2_desc.validator.params_ordered.map(&:name)
 
-    arch_v1_params.sort_by(&:to_s).should == arch_v2_params.sort_by(&:to_s)
+    expect(arch_v1_params.sort_by(&:to_s)).to eq(arch_v2_params.sort_by(&:to_s))
   end
 
   it "should replace parameter name in a group when it comes from concern" do
-    Apipie["overridden_concern_resources#update"].params.has_key?(:user).should == true
+    expect(Apipie["overridden_concern_resources#update"].params.has_key?(:user)).to eq(true)
   end
 
   it "shouldn't replace parameter name in a group redefined in the controller" do
-    Apipie["overridden_concern_resources#create"].params.has_key?(:concern).should == true
-    Apipie["overridden_concern_resources#create"].params.has_key?(:user).should == false
+    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)
   end
 
 it "shouldn't replace name of a parameter defined in the controller" do
-    Apipie["overridden_concern_resources#custom"].params.has_key?(:concern).should == true
-    Apipie["overridden_concern_resources#custom"].params.has_key?(:user).should == false
+    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)
   end
 
 end