apipie-rails 0.5.20 → 1.2.3

data/spec/{controllers → lib/apipie}/apipies_controller_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'fileutils'
 require "json-schema"
 
-describe Apipie::ApipiesController do
+describe Apipie::ApipiesController, type: :controller do
 
   describe "GET index" do
 
@@ -47,6 +47,30 @@ describe Apipie::ApipiesController do
 
       assert_response :not_found
     end
+
+    it "succeeds on method details with a supported language" do
+      allow(Apipie.configuration).to receive(:languages).and_return(%w[en es])
+
+      get :index, :params => { :version => "2.0", :resource => "architectures", :method => "index.es" }
+
+      assert_response :success
+    end
+
+    it "succeeds on method details with the default language" do
+      allow(Apipie.configuration).to receive_messages(default_locale: "en", languages: [])
+
+      get :index, :params => { :version => "2.0", :resource => "architectures", :method => "index.en" }
+
+      assert_response :success
+    end
+
+    it "returns not_found on a method with an unsupported language" do
+      allow(Apipie.configuration).to receive(:languages).and_return(%w[en es])
+
+      get :index, :params => { :version => "2.0", :resource => "architectures", :method => "index.jp" }
+
+      assert_response :not_found
+    end
   end
 
   describe "reload_controllers" do
@@ -134,7 +158,7 @@ describe Apipie::ApipiesController do
   describe "GET index as swagger" do
 
     let(:swagger_schema) do
-      File.read(File.join(File.dirname(__FILE__),"../lib/swagger/openapi_2_0_schema.json"))
+      File.read("#{Rails.root.parent}/lib/swagger/openapi_2_0_schema.json")
     end
 
     it "outputs swagger when format is json and type is swagger" do
@@ -184,6 +208,7 @@ describe Apipie::ApipiesController do
       get :index
       expect(test).to eq(true)
     end
+
     it "remove all resources" do
       Apipie.configuration.authorize = Proc.new do |&args|
         false
@@ -191,6 +216,7 @@ describe Apipie::ApipiesController do
       get :index
       expect(assigns(:doc)[:resources]).to eq({})
     end
+
     it "remove all methods" do
       Apipie.configuration.authorize = Proc.new do |controller, method, doc|
         !method
@@ -200,6 +226,7 @@ describe Apipie::ApipiesController do
       expect(assigns(:doc)[:resources]["twitter_example"][:methods]).to eq([])
       expect(assigns(:doc)[:resources]["users"][:methods]).to eq([])
     end
+
     it "remove specific method" do
       Apipie.configuration.authorize = nil
       get :index
@@ -216,6 +243,7 @@ describe Apipie::ApipiesController do
       expect(assigns(:doc)[:resources]["users"][:methods].size).to eq(users_methods - 1)
       expect(assigns(:doc)[:resources]["twitter_example"][:methods].size).to eq(twitter_example_methods)
     end
+
     it "does not allow access to swagger when authorization is set" do
       get :index, :params => { :format => "json", :type => "swagger"}
 
@@ -228,13 +256,13 @@ describe Apipie::ApipiesController do
     let(:cache_dir) { File.join(Rails.root, "tmp", "apipie-cache") }
 
     before do
-      FileUtils.rm_r(cache_dir) if File.exists?(cache_dir)
-      FileUtils.mkdir_p(File.join(cache_dir, "apidoc", "v1", "resource"))
+      FileUtils.rm_r(cache_dir) if File.exist?(cache_dir)
+      FileUtils.mkdir_p(File.join(cache_dir, "apidoc", "v1", "resource-with-namespace"))
       File.open(File.join(cache_dir, "apidoc", "v1.html"), "w") { |f| f << "apidoc.html cache v1" }
       File.open(File.join(cache_dir, "apidoc", "v2.html"), "w") { |f| f << "apidoc.html cache v2" }
       File.open(File.join(cache_dir, "apidoc", "v1.json"), "w") { |f| f << "apidoc.json cache" }
-      File.open(File.join(cache_dir, "apidoc", "v1", "resource.html"), "w") { |f| f << "resource.html cache" }
-      File.open(File.join(cache_dir, "apidoc", "v1", "resource", "method.html"), "w") { |f| f << "method.html cache" }
+      File.open(File.join(cache_dir, "apidoc", "v1", "resource-with-namespace.html"), "w") { |f| f << "resource-with-namespace.html cache" }
+      File.open(File.join(cache_dir, "apidoc", "v1", "resource-with-namespace", "method.html"), "w") { |f| f << "method.html cache" }
 
       Apipie.configuration.use_cache = true
       @orig_cache_dir = Apipie.configuration.cache_dir
@@ -247,27 +275,71 @@ describe Apipie::ApipiesController do
       Apipie.configuration.use_cache = false
       Apipie.configuration.default_version = @orig_version
       Apipie.configuration.cache_dir = @orig_cache_dir
-      # FileUtils.rm_r(cache_dir) if File.exists?(cache_dir)
+      # FileUtils.rm_r(cache_dir) if File.exist?(cache_dir)
     end
 
-    it "uses the file in cache dir instead of generating the content on runtime" do
-      get :index
-      expect(response.body).to eq("apidoc.html cache v1")
-      get :index, :params => { :version => 'v1' }
-      expect(response.body).to eq("apidoc.html cache v1")
-      get :index, :params => { :version => 'v2' }
-      expect(response.body).to eq("apidoc.html cache v2")
-      get :index, :params => { :version => 'v1', :format => "html" }
-      expect(response.body).to eq("apidoc.html cache v1")
-      get :index, :params => { :version => 'v1', :format => "json" }
-      expect(response.body).to eq("apidoc.json cache")
-      get :index, :params => { :version => 'v1', :format => "html", :resource => "resource" }
-      expect(response.body).to eq("resource.html cache")
-      get :index, :params => { :version => 'v1', :format => "html", :resource => "resource", :method => "method" }
-      expect(response.body).to eq("method.html cache")
+    context 'when the file exists' do
+      it "uses the file in cache dir instead of generating the content on runtime" do
+        get :index
+        expect(response.body).to eq("apidoc.html cache v1")
+
+        get :index, :params => { :version => 'v1' }
+        expect(response.body).to eq("apidoc.html cache v1")
+
+        get :index, :params => { :version => 'v2' }
+        expect(response.body).to eq("apidoc.html cache v2")
+
+        get :index, :params => { :version => 'v1', :format => "html" }
+        expect(response.body).to eq("apidoc.html cache v1")
+
+        get :index, :params => { :version => 'v1', :format => "json" }
+        expect(response.body).to eq("apidoc.json cache")
+
+        get :index, :params => { :version => 'v1', :format => "html", :resource => "resource-with-namespace" }
+        expect(response.body).to eq("resource-with-namespace.html cache")
+
+        get :index, :params => { :version => 'v1', :format => "html", :resource => "resource-with-namespace", :method => "method" }
+        expect(response.body).to eq("method.html cache")
+      end
     end
 
-  end
+    context 'when the file does not exist' do
+      it 'returns a not found' do
+        get :index, :params => { :version => 'v3-does-not-exist' }
+        expect(response).to have_http_status(:not_found)
+      end
+    end
+
+    context 'preventing path traversal' do
+      context 'when resource contains ..' do
+        it "returns a not found" do
+          get :index, :params => { :version => 'v1', :format => "html", :resource => "../resource-with-namespace", :method => "method" }
+          expect(response).to have_http_status(:not_found)
+        end
+      end
 
+      context 'when method contains ..' do
+        it "returns a not found" do
+          get :index, :params => { :version => 'v1', :format => "html", :resource => "resource-with-namespace", :method => "../method" }
+          expect(response).to have_http_status(:not_found)
+        end
+      end
+
+      context 'when version contains ..' do
+        it "returns a not found" do
+          get :index, :params => { :version => '../v1', :format => "html", :resource => "resource-with-namespace", :method => "method" }
+          expect(response).to have_http_status(:not_found)
+        end
+      end
+
+      context 'when format contains ..' do
+        it "returns a not found" do
+          get :index, :params => { :version => 'v1', :format => "../html", :resource => "resource-with-namespace", :method => "method" }
+          expect(response).to have_http_status(:not_found)
+        end
+      end
+    end
+
+  end
 
 end

data/spec/lib/apipie/application_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+describe Apipie::Application do
+
+  describe "api_controllers_paths" do
+    before do
+      Apipie.configuration.api_controllers_matcher = [File.join(Rails.root, "app", "controllers", "**","*.rb"),
+                                                      File.join(Rails.root, "lib", "**","*.rb")]
+    end
+
+    it "should support receiving array as parameter" do
+      expect { Apipie.api_controllers_paths}.
+        not_to raise_error
+    end
+
+
+  end
+
+  shared_examples 'resource id' do
+    let(:resource_class) { Api::V2::Nested::ArchitecturesController }
+    let(:base_url) { '/some-api' }
+
+    before { allow(described_class).to receive(:get_base_url).and_return(base_url) }
+
+    context "with namespaced_resources enabled" do
+      before { Apipie.configuration.namespaced_resources = true }
+      after { Apipie.configuration.namespaced_resources = false }
+
+      it "returns the namespaces" do
+        is_expected.to eq('api-v2-nested-architectures')
+      end
+
+      context "with an undefined base url" do
+        let(:base_url) { nil }
+
+        it "should not raise an error" do
+          expect { method_call }.not_to raise_error
+        end
+      end
+    end
+
+    context "with namespaced_resources disabled" do
+      before { Apipie.configuration.namespaced_resources = false }
+
+      it "returns the controller name" do
+        is_expected.to eq('architectures')
+      end
+    end
+  end
+
+  describe '.get_resource_id' do
+    subject(:method_call) { Apipie.get_resource_id(resource_class) }
+
+    it_behaves_like 'resource id'
+  end
+
+  describe '.get_resource_name' do
+    subject(:method_call) { Apipie.get_resource_name(resource_class) }
+
+    it_behaves_like 'resource id'
+  end
+end

data/spec/lib/apipie/configuration_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Apipie::Configuration' do
+  let(:configuration) { Apipie::Configuration.new }
+
+  describe '#api_action_matcher=' do
+    subject(:setter) { configuration.api_action_matcher = matcher }
+
+    let(:matcher) { proc { |_| :some_action } }
+
+    it { is_expected.to eq(matcher) }
+
+    context 'when matcher does not implement .call method' do
+      let(:matcher) { 'I do not implement .call' }
+
+      it 'raises and exception' do
+        expect { setter }.to raise_error('Must implement .call method')
+      end
+    end
+  end
+
+  describe 'generator configuration' do
+    let(:generator_config) { configuration.generator }
+
+    describe '#swagger' do
+      subject(:setter) { generator_config.swagger.include_warning_tags = true }
+
+      it 'assigns the correct value' do
+        expect { setter }
+          .to change(configuration.generator.swagger, :include_warning_tags?)
+          .from(false)
+          .to(true)
+      end
+    end
+  end
+end

data/spec/lib/apipie/extractor/collector_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Apipie::Extractor::Collector do
+  let(:recorder) { described_class.new }
+
+  describe '#ignore_call?' do
+    subject { recorder.ignore_call?(record) }
+
+    let(:record) { { controller: controller, action: action } }
+    let(:controller) { ActionController::Base }
+    let(:action) { nil }
+
+    context 'when controller is nil' do
+      let(:controller) { nil }
+
+      it { is_expected.to be true }
+    end
+
+    context 'when controller is ignored' do
+      before do
+        allow(Apipie.configuration).to receive(:ignored_by_recorder).and_return(['ActionController::Bas'])
+      end
+
+      it { is_expected.to be true }
+    end
+
+    context 'when resource#method is ignored' do
+      let(:action) { 'ignored_action' }
+
+      before do
+        allow(Apipie.configuration).to receive(:ignored_by_recorder).and_return(['ActionController::Bas#ignored_action'])
+      end
+
+      it { is_expected.to be true }
+    end
+
+    context 'when controller is not an API controller' do
+      before do
+        allow(Apipie::Extractor).to receive(:controller_path).with('action_controller/base').and_return('foo')
+        allow(Apipie).to receive(:api_controllers_paths).and_return([])
+      end
+
+      it { is_expected.to be true }
+    end
+
+    context 'when controller is an API controller' do
+      before do
+        allow(Apipie::Extractor).to receive(:controller_path).with('action_controller/base').and_return('foo')
+        allow(Apipie).to receive(:api_controllers_paths).and_return(['foo'])
+      end
+
+      it { is_expected.to be_falsey }
+    end
+  end
+end

data/spec/lib/apipie/extractor/recorder_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Apipie::Extractor::Recorder' do
+  let(:recorder) { Apipie::Extractor::Recorder.new }
+  let(:controller) do
+    controller = ActionController::Metal.new
+    controller.set_request!(request)
+    controller
+  end
+
+  describe '#analyse_controller' do
+    subject do
+      recorder.analyse_controller(controller)
+      recorder.record[:action]
+    end
+
+    let(:action) { :show }
+
+    let(:request) do
+      request = ActionDispatch::Request.new({})
+      request.request_parameters = { action: action }
+      request
+    end
+
+    it { is_expected.to eq(action) }
+
+    context 'when a api_action_matcher is configured' do
+      let(:matcher_action) { "#{action}_from_new_matcher" }
+
+      before do
+        Apipie.configuration.api_action_matcher = proc { |_| matcher_action }
+      end
+
+      it { is_expected.to eq(matcher_action) }
+    end
+  end
+
+  describe '#analyse_functional_test' do
+    context 'with multipart-form data' do
+      subject do
+        recorder.analyse_controller(controller)
+        recorder.analyze_functional_test(test_context)
+        recorder.record[:request_data]
+      end
+
+      let(:test_context) do
+        double(controller: controller, request: request, response: ActionDispatch::Response.new(200))
+      end
+
+      let(:file) do
+        instance_double(
+          ActionDispatch::Http::UploadedFile,
+          original_filename: 'file.txt',
+          content_type: 'text/plain',
+          size: '1MB'
+        )
+      end
+
+      let(:request) do
+        request = ActionDispatch::Request.new({})
+        request.request_method = 'POST'
+        request.headers['Content-Type'] = 'multipart/form-data'
+        request.request_parameters = { file: file }
+        request
+      end
+
+      before do
+        allow(file).to receive(:is_a?).and_return(false)
+        allow(file).to receive(:is_a?).with(ActionDispatch::Http::UploadedFile).and_return(true)
+      end
+
+      it { is_expected.to include("filename=\"#{file.original_filename}\"") }
+    end
+  end
+end

data/spec/lib/{extractor → apipie/extractor}/writer_spec.rb

@@ -6,7 +6,8 @@ describe Apipie::Extractor::Writer do
   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) { {
+  let(:records) {
+    {
     "concern_resources#show" =>
       [{
         :controller=>ConcernsController,
@@ -31,7 +32,8 @@ describe Apipie::Extractor::Writer do
       }]
     }
   }
-  let(:loaded_records) { {
+  let(:loaded_records) {
+    {
     "concern_resources#show" =>
       [{
         "verb"=>:GET,
@@ -57,16 +59,16 @@ describe Apipie::Extractor::Writer do
     }
   }
 
-  context 'with doc_path overriden in configuration' do
+  context 'with doc_path overridden in configuration' do
     around(:each) do |example|
       standard_path = Apipie.configuration.doc_path
-      Apipie.configuration.doc_path = 'user_specified_doc_path'
+      Apipie.configuration.doc_path = 'tmp/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'))
+      expect(writer_class.examples_file).to eql(File.join(Rails.root, 'tmp', 'user_specified_doc_path', 'apipie_examples.json'))
     end
   end
 
@@ -104,7 +106,7 @@ describe Apipie::Extractor::Writer do
     end
 
     after do
-      File.unlink(test_examples_file) if File.exists?(test_examples_file)
+      File.unlink(test_examples_file) if File.exist?(test_examples_file)
     end
   end
 end

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

@@ -14,5 +14,12 @@ describe Apipie::FileHandler do
       it { expect(file_handler.match? path).to be_falsy }
       it { expect { file_handler.match? path }.to_not raise_error }
     end
+
+    context 'when the path contans an invalid byte sequence in UTF-8' do
+      let(:path) { "%B6" }
+
+      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/apipie/generator/swagger/config_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::Config do
+  let(:config) { described_class.clone.instance }
+
+  before { Singleton.__init__(described_class) }
+
+  describe 'deprecation warnings' do
+    context 'when a deprecated method is call' do
+      subject(:deprecated_method_call) { config.swagger_include_warning_tags? }
+
+      it 'returns a deprecations warning' do
+        expect { deprecated_method_call }
+          .to output(/DEPRECATION WARNING: config.swagger_include_warning_tags is deprecated/)
+          .to_stderr
+      end
+    end
+  end
+end

data/spec/lib/apipie/generator/swagger/context_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::Context do
+  let(:allow_null) { true }
+  let(:in_schema) { true }
+  let(:http_method) { 'get' }
+  let(:prefix) { nil }
+
+  let(:context_instance) do
+    described_class.new(
+      allow_null: allow_null,
+      http_method: http_method,
+      in_schema: in_schema,
+      controller_method: 'show',
+      prefix: prefix
+    )
+  end
+
+  describe '#in_schema?' do
+    subject { context_instance }
+
+    it { is_expected.to be_in_schema }
+
+    context 'when in_schema is false' do
+      let(:in_schema) { false }
+
+      it { is_expected.not_to be_in_schema }
+    end
+  end
+
+  describe '#allow_null?' do
+    subject { context_instance }
+
+    it { is_expected.to be_allow_null }
+
+    context 'when allow_null is false' do
+      let(:allow_null) { false }
+
+      it { is_expected.not_to be_allow_null }
+    end
+  end
+
+  describe '#add_to_prefix!' do
+    before { context_instance.add_to_prefix!('some-prefix') }
+
+    subject { context_instance.prefix }
+
+    it { is_expected.to eq('some-prefix') }
+
+    context 'when context has already a prefix' do
+      let(:prefix) { 'existing-prefix' }
+
+      it { is_expected.to eq('existing-prefix[some-prefix]') }
+    end
+  end
+end

data/spec/lib/apipie/generator/swagger/method_description/api_schema_service_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe Apipie::Generator::Swagger::MethodDescription::ApiSchemaService do
+  let(:path) { '/api' }
+  let(:http_method) { 'get' }
+  let(:resource_id) { 'users' }
+  let(:method_description_description) { nil }
+  let(:tags) { [] }
+
+  let(:dsl_data) do
+    ActionController::Base
+      .send(:_apipie_dsl_data_init)
+      .merge(
+        {
+          description: method_description_description,
+          api_args: [[http_method, path, 'Some api description', { deprecated: true }]],
+          tag_list: tags
+        }
+      )
+  end
+
+  let(:resource_desc) do
+    Apipie::ResourceDescription.new(UsersController, resource_id)
+  end
+
+  let(:method_description) do
+    Apipie::Generator::Swagger::MethodDescription::Decorator.new(
+      Apipie::MethodDescription.new(:show, resource_desc, dsl_data)
+    )
+  end
+
+  let(:service) { described_class.new(method_description) }
+
+  describe '#call' do
+    subject(:schema) { service.call }
+
+    it 'returns the path' do
+      expect(schema).to include(path)
+    end
+
+    it 'returns the http method' do
+      expect(schema[path]).to include(http_method)
+    end
+
+    it 'returns the correct attributes' do
+      expect(schema[path][http_method].keys).to include(
+        :tags,
+        :consumes,
+        :operationId,
+        :parameters,
+        :responses
+      )
+    end
+  end
+
+  describe 'tags' do
+    subject { service.call[path][http_method][:tags] }
+
+    it { is_expected.to eq([resource_id]) }
+
+    context 'when tags are available' do
+      let(:tags) { ['Tag 1', 'Tag 2'] }
+
+      it { is_expected.to include(*tags) }
+    end
+
+    context 'when Apipie.configuration.generator.swagger.skip_default_tags is enabled' do
+      before { Apipie.configuration.generator.swagger.skip_default_tags = true }
+      after { Apipie.configuration.generator.swagger.skip_default_tags = false }
+
+      it { is_expected.to be_empty }
+
+      context 'when tags are available' do
+        let(:tags) { ['Tag 1', 'Tag 2'] }
+
+        it { is_expected.to eq(tags) }
+      end
+    end
+
+    context 'when Apipie.configuration.generator.swagger.include_warning_tags is enabled' do
+      before { Apipie.configuration.generator.swagger.include_warning_tags = true }
+
+      context 'when warnings are issued' do
+        before do
+          Apipie::Generator::Swagger::Warning.for_code(
+            Apipie::Generator::Swagger::Warning::MISSING_METHOD_SUMMARY_CODE,
+            'some_method'
+          ).warn_through_writer
+        end
+
+        it { is_expected.to include('warnings issued') }
+      end
+    end
+  end
+
+  describe 'consumes' do
+    subject { service.call[path]['get'][:consumes] }
+
+    it { is_expected.to eq(['application/x-www-form-urlencoded', 'multipart/form-data']) }
+
+    context 'when content type input is json' do
+      before { Apipie.configuration.generator.swagger.content_type_input = :json }
+
+      it { is_expected.to eq(['application/json']) }
+    end
+  end
+
+  describe 'description' do
+    subject { service.call[path]['get'][:description] }
+
+    it { is_expected.to be_blank }
+
+    context 'when description for method description exists' do
+      let(:method_description_description) { 'Some description' }
+
+      it { is_expected.to eq(method_description_description) }
+    end
+  end
+end