apipierails3 0.0.1

data/spec/lib/extractor/extractor_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+describe Apipie::Extractor do
+  it 'handles routes without (.:format)' do
+    Apipie::Extractor.apis_from_routes.each do |(controller, action), apis|
+      apis.each { |api| expect(api[:path]).not_to be_nil }
+    end
+  end
+end

data/spec/lib/extractor/middleware_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe Apipie::Extractor::Recorder::Middleware do
+  let(:app) { lambda { |env| [200, env, "app"] } }
+  let(:stack) { Apipie::Extractor::Recorder::Middleware.new(app) }
+  let(:request) { Rack::MockRequest.new(stack) }
+  let(:response) { request.get('/') }
+
+  it 'correctly process request without recording' do
+    expect(stack).not_to receive(:analyze)
+    response
+  end
+
+  it "analyze request if recording is set" do
+    Apipie.configuration.record = true
+    expect(Apipie::Extractor.call_recorder).to receive(:analyse_env)
+    expect(Apipie::Extractor.call_recorder).to receive(:analyse_response)
+    expect(Apipie::Extractor).to receive(:clean_call_recorder)
+    response
+  end
+
+  describe 'with a multipart post' do
+    let(:form_hash) do
+      {
+        'stringbody' => 'this is a string body',
+        'filebody' => {:head => 'X-Fake-Header: fake1\r\n'},
+        'files' => {
+          '0' => {:head => 'X-Fake-Header: fake2\r\n'}
+        }
+      }
+    end
+
+    let(:response) do
+      request.post('/', 'rack.request.form_hash' => form_hash)
+    end
+
+    it 'reformats form parts' do
+      Apipie.configuration.record = true
+      # expect reformat_multipart_data to invoke content_disposition
+      expect(Apipie::Extractor.call_recorder).to receive(:content_disposition)
+      response
+    end
+  end
+end

data/spec/lib/extractor/writer_spec.rb

@@ -0,0 +1,110 @@
+require "spec_helper"
+
+describe Apipie::Extractor::Writer do
+
+  let(:collector) { double "collector" }
+  let(:writer_class) { Apipie::Extractor::Writer }
+  let(:writer) { writer_class.new(collector) }
+  let(:test_examples_file) { File.join(Rails.root, "doc", "apipie_examples_test.json") }
+  let(:records) { {
+    "concern_resources#show" =>
+      [{
+        :controller=>ConcernsController,
+        :action=>"show",
+        :verb=>:GET,
+        :path=>"/api/concerns/5",
+        :params=>{},
+        :query=>"session=secret_hash",
+        :request_data=>nil,
+        :response_data=>"OK {\"session\"=>\"secret_hash\", \"id\"=>\"5\", \"controller\"=>\"concerns\", \"action\"=>\"show\"}",
+        :code=>"200"
+      }, {
+        :controller=>ConcernsController,
+        :action=>"show",
+        :verb=>:GET,
+        :path=>"/api/concerns/5",
+        :params=>{},
+        :query=>"",
+        :request_data=>nil,
+        :response_data=>"OK {\"id\"=>\"5\", \"controller\"=>\"concerns\", \"action\"=>\"show\"}",
+        :code=>"200"
+      }]
+    }
+  }
+  let(:loaded_records) { {
+    "concern_resources#show" =>
+      [{
+        "verb"=>:GET,
+        "path"=>"/api/concerns/5",
+        "versions"=>["development"],
+        "query"=>"session=secret_hash",
+        "request_data"=>nil,
+        "response_data"=>"OK {\"session\"=>\"secret_hash\", \"id\"=>\"5\", \"controller\"=>\"concerns\", \"action\"=>\"show\"}",
+        "code"=>"200",
+        "show_in_doc"=>1,
+        "recorded"=>true
+      }, {
+        "verb"=>:GET,
+        "path"=>"/api/concerns/5",
+        "versions"=>["development"],
+        "query"=>"",
+        "request_data"=>nil,
+        "response_data"=>"OK {\"id\"=>\"5\", \"controller\"=>\"concerns\", \"action\"=>\"show\"}",
+        "code"=>"200",
+        "show_in_doc"=>0,
+        "recorded"=>true
+      }]
+    }
+  }
+
+  context 'with doc_path overriden in configuration' do
+    around(:each) do |example|
+      standard_path = Apipie.configuration.doc_path
+      Apipie.configuration.doc_path = 'user_specified_doc_path'
+      example.run
+      Apipie.configuration.doc_path = standard_path
+    end
+
+    it 'should use the doc_path specified in configuration' do
+      expect(writer_class.examples_file).to eql(File.join(Rails.root, 'user_specified_doc_path', 'apipie_examples.json'))
+    end
+  end
+
+  context 'when compressing examples' do
+    around(:each) do |example|
+      Apipie.configuration.compress_examples = true
+      example.run
+      FileUtils.rm(writer_class.examples_file) if File.exist?(writer_class.examples_file)
+      Apipie.configuration.compress_examples = nil
+    end
+
+    it 'should write to a compressed file' do
+      expect(writer_class.examples_file).to match(/\.gz$/)
+      writer_class.write_recorded_examples(records)
+      expect(File.exist?(writer_class.examples_file))
+    end
+
+    it 'should read from a compressed file' do
+      writer_class.write_recorded_examples(records)
+      expected_string = writer_class.send(:serialize_examples, records)
+      expect(writer_class.load_recorded_examples)
+        .to eql(writer_class.send(:deserialize_examples, expected_string))
+    end
+  end
+
+  describe "storing of examples" do
+    before do
+      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
+      expect(writer.send(:load_recorded_examples)).to eql(loaded_records)
+    end
+
+    after do
+      File.unlink(test_examples_file) if File.exists?(test_examples_file)
+    end
+  end
+end

data/spec/lib/file_handler_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe Apipie::FileHandler do
+
+  describe "match?" do
+    let(:file_handler) { Apipie::FileHandler.new File.dirname(__FILE__) }
+
+    it { expect(file_handler.match? 'file_handler_spec.rb').to be_truthy }
+    it { expect(file_handler.match? 'foo.bar').to be_falsy }
+
+    context 'path contains null bytes' do
+      let(:path) { "foo%00.bar" }
+
+      it { expect(file_handler.match? path).to be_falsy }
+      it { expect { file_handler.match? path }.to_not raise_error }
+    end
+  end
+end

data/spec/lib/method_description_spec.rb

@@ -0,0 +1,98 @@
+require "spec_helper"
+
+describe Apipie::MethodDescription do
+
+  let(:dsl_data) { ActionController::Base.send(:_apipie_dsl_data_init) }
+
+  describe "metadata" do
+
+    before(:each) do
+      @resource = Apipie::ResourceDescription.new(ApplicationController, "dummy")
+    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
+
+    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
+
+  end
+
+  describe "deprecated flag" do
+    before(:each) do
+      @resource = Apipie::ResourceDescription.new(ApplicationController, "dummy")
+    end
+
+    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)
+    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)
+    end
+  end
+
+  describe "params descriptions" do
+
+    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
+
+    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
+
+    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
+
+  end
+
+  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 "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'])
+    end
+  end
+
+
+  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] }
+
+      expect {Apipie::MethodDescription.new(:a, @resource, dsl_data)}.to raise_error(Apipie::ReturnsMultipleDefinitionError)
+    end
+  end
+
+
+end

data/spec/lib/param_description_spec.rb

@@ -0,0 +1,345 @@
+require "spec_helper"
+
+describe Apipie::ParamDescription do
+
+  let(:dsl_data) { ActionController::Base.send(:_apipie_dsl_data_init) }
+
+  let(:resource_desc) do
+    Apipie::ResourceDescription.new(UsersController, "users")
+  end
+
+  let(:method_desc) do
+    Apipie::MethodDescription.new(:show, resource_desc, dsl_data)
+  end
+
+  describe "metadata" do
+
+    it "should return nil when no metadata is provided" do
+      param = Apipie::ParamDescription.new(method_desc, :some_param, String)
+      expect(param.to_json[:metadata]).to eq(nil)
+    end
+
+    it "should return the metadata" do
+      meta = {
+        :lenght => 32,
+        :weight => '830g'
+      }
+      param = Apipie::ParamDescription.new(method_desc, :some_param, String, :meta => meta)
+      expect(param.to_json[:metadata]).to eq(meta)
+    end
+
+  end
+
+  describe "show option" do
+
+    it "should return true when show option is not provided" do
+      param = Apipie::ParamDescription.new(method_desc, :some_param, String)
+      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)
+      expect(param.to_json[:show]).to eq(true)
+
+      param = Apipie::ParamDescription.new(method_desc, :some_param, String, :show => false)
+      expect(param.to_json[:show]).to eq(false)
+    end
+
+  end
+
+  describe "full_name" do
+    context "with no nested parameters" do
+
+      it "should return name" do
+        param = Apipie::ParamDescription.new(method_desc, :some_param, String)
+        expect(param.to_json[:full_name]).to eq('some_param')
+      end
+
+    end
+
+    context "with nested parameters" do
+
+      it "should return the parameter's name nested in the parents name" do
+        parent_param = Apipie::ParamDescription.new(method_desc, :parent, String)
+        nested_param = Apipie::ParamDescription.new(method_desc, :nested, String, :parent => parent_param)
+
+        expect(nested_param.to_json[:full_name]).to eq('parent[nested]')
+      end
+
+      context "with the parent parameter set to not show" do
+
+        it "should return just the parameter's name" do
+          parent_param = Apipie::ParamDescription.new(method_desc, :parent, String, :show => false)
+          nested_param = Apipie::ParamDescription.new(method_desc, :nested, String, :parent => parent_param)
+
+          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)
+      expect(param.validator).to be_nil
+    end
+
+    it "should throw exception on unknown validator" do
+      expect { Apipie::ParamDescription.new(method_desc, :param, :unknown) }.to raise_error(RuntimeError, /Validator.*not found/)
+    end
+
+    it "should pick type validator" do
+      expect(Apipie::Validator::BaseValidator).to receive(:find).and_return(:validator_instance)
+      param = Apipie::ParamDescription.new(method_desc, :param, String)
+      expect(param.validator).to eq(:validator_instance)
+    end
+
+  end
+
+  describe "concern substitution" do
+
+    let(:concern_dsl_data) { dsl_data.merge(:from_concern => true) }
+
+    let(:concern_resource_desc) do
+      Apipie::ResourceDescription.new(ConcernsController, "concerns")
+    end
+
+    let(:concern_method_desc) do
+      Apipie::MethodDescription.new(:show, concern_resource_desc, concern_dsl_data)
+    end
+
+    it "should replace string parameter name with colon prefix" do
+      param = Apipie::ParamDescription.new(concern_method_desc, ":string_subst", String)
+      expect(param.name).to eq("string")
+    end
+
+    it "should replace symbol parameter name" do
+      param = Apipie::ParamDescription.new(concern_method_desc, :concern, String)
+      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)
+      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)
+      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)
+      expect(param.name).to eq(:param)
+    end
+  end
+
+
+  describe "required_by_default config option" do
+    context "parameters required by default" do
+
+      before { Apipie.configuration.required_by_default = true }
+
+      it "should set param as required by default" do
+        param = Apipie::ParamDescription.new(method_desc, :required_by_default, String)
+        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)
+        expect(param.required).to be false
+      end
+
+    end
+
+    context "parameters optional by default" do
+
+      before { Apipie.configuration.required_by_default = false }
+
+      it "should set param as optional by default" do
+        param = Apipie::ParamDescription.new(method_desc, :optional_by_default, String)
+        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)
+        expect(param.required).to be true
+      end
+
+    end
+
+  end
+
+  describe "required params on given actions" do
+    let(:method_desc) do
+      Apipie::MethodDescription.new(:create, resource_desc, dsl_data)
+    end
+
+    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)
+        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])
+        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)
+        expect(param.required).to be false
+      end
+    end
+  end
+
+  describe "required params in action aware validator" do
+
+    subject { method_description.params[:user].validator.params_ordered }
+
+    let(:required) do
+      subject.find_all(&:required).map(&:name)
+    end
+
+    let(:allowed_nil) do
+      subject.find_all(&:allow_nil).map(&:name)
+    end
+
+    context "with resource creation" do
+
+      let(:method_description) do
+        Apipie.get_method_description(UsersController, :create)
+      end
+
+      it "makes the param required" do
+        expect(required).to include :name
+        expect(required).to include :pass
+      end
+
+      it "doesn't allow nil" do
+        expect(allowed_nil).not_to include :name
+        expect(allowed_nil).not_to include :pass
+      end
+    end
+
+    context "with resource update" do
+
+      let(:method_description) do
+        Apipie.get_method_description(UsersController, :update)
+      end
+
+      it "doesn't make the param required" do
+        expect(required).not_to include :name
+        expect(required).not_to include :pass
+      end
+
+      it "doesn't allow nil" do
+        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
+        expect(allowed_nil).not_to include :membership
+      end
+    end
+
+    context "with explicitly setting action type in param group" do
+      let(:method_description) do
+        Apipie.get_method_description(UsersController, :admin_create)
+      end
+
+      it "makes the param required" do
+        expect(required).to include :name
+        expect(required).to include :pass
+      end
+
+      it "doesn't allow nil" do
+        expect(allowed_nil).not_to include :name
+        expect(allowed_nil).not_to include :pass
+      end
+    end
+  end
+
+
+  describe 'sub params' do
+
+    context 'with HashValidator' do
+
+      subject do
+        Apipie::ParamDescription.new(method_desc, :param, Hash) do
+          param :answer, Fixnum
+        end
+      end
+
+      it "should include the nested params in the json" do
+        sub_params = subject.to_json[:params]
+        expect(sub_params.size).to eq(1)
+        sub_param = sub_params.first
+        expect(sub_param[:name]).to eq("answer")
+        expect(sub_param[:full_name]).to eq("param[answer]")
+      end
+
+    end
+
+    context 'with NestedValidator' do
+
+      subject do
+        Apipie::ParamDescription.new(method_desc, :param, Array) do
+          param :answer, Fixnum
+        end
+      end
+
+      it "should include the nested params in the json" do
+        sub_params = subject.to_json[:params]
+        expect(sub_params.size).to eq(1)
+        sub_param = sub_params.first
+        expect(sub_param[:name]).to eq("answer")
+        expect(sub_param[:full_name]).to eq("param[answer]")
+      end
+
+    end
+
+    context 'with flat validator' do
+
+      subject do
+        Apipie::ParamDescription.new(method_desc, :param, String)
+      end
+
+      it "should include the nested params in the json" do
+        expect(subject.to_json[:params]).to be_nil
+      end
+
+    end
+
+  end
+
+  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") }.not_to raise_error
+      expect { param.validate(Fixnum) }.to raise_error(Apipie::ParamInvalid)
+    end
+  end
+
+end