apipie-rails 0.5.19 → 1.3.0

data/spec/dummy/config/environments/development.rb

@@ -13,9 +13,6 @@ Dummy::Application.configure do
   config.consider_all_requests_local       = true
   config.action_controller.perform_caching = false
 
-  # Don't care if the mailer can't send
-  config.action_mailer.raise_delivery_errors = false
-
   # Print deprecation notices to the Rails logger
   config.active_support.deprecation = :log
 

data/spec/dummy/config/environments/production.rb

@@ -34,9 +34,6 @@ Dummy::Application.configure do
   # Enable serving of images, stylesheets, and javascripts from an asset server
   # config.action_controller.asset_host = "http://assets.example.com"
 
-  # Disable delivery errors, bad email addresses will be ignored
-  # config.action_mailer.raise_delivery_errors = false
-
   # Enable threaded mode
   # config.threadsafe!
 

data/spec/dummy/config/environments/test.rb

@@ -20,11 +20,6 @@ Dummy::Application.configure do
   # Disable request forgery protection in test environment
   config.action_controller.allow_forgery_protection    = false
 
-  # Tell Action Mailer not to deliver emails to the real world.
-  # The :test delivery method accumulates sent emails in the
-  # ActionMailer::Base.deliveries array.
-  config.action_mailer.delivery_method = :test
-
   # Use SQL instead of Active Record's schema dumper when creating the test database.
   # This is necessary if your schema can't be completely dumped by the schema dumper,
   # like if you have constraints or database-specific column types

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

@@ -23,7 +23,7 @@ Apipie.configure do |config|
   #     rake apipie:cache
   #
   config.use_cache = Rails.env.production?
-  # config.cache_dir = File.join(Rails.root, "public", "apipie-cache") # optional
+  config.cache_dir = File.join(Rails.root, "tmp", "apipie-cache") # optional
 
   # set to enable/disable reloading controllers (and the documentation with it),
   # by default enabled in development
@@ -89,7 +89,7 @@ class Apipie::Validator::IntegerValidator < Apipie::Validator::BaseValidator
   end
 
   def self.build(param_description, argument, options, block)
-    if argument == Integer || argument == Fixnum
+    if argument == Integer
       self.new(param_description, argument)
     end
   end

data/spec/dummy/config/routes.rb

@@ -8,9 +8,11 @@ Dummy::Application.routes.draw do
       resources :users do
         collection do
           post :create_route
+          get :multiple_required_params
         end
       end
       resources :concerns, :only => [:index, :show]
+      get '/:resource_id/:custom_subst' => 'concerns#custom'
       namespace :files do
         get '/*file_path', format: false, :action => 'download'
       end
@@ -44,6 +46,12 @@ Dummy::Application.routes.draw do
       get "/pets/returns_response_with_valid_array" => "pets#returns_response_with_valid_array"
       get "/pets/returns_response_with_invalid_array" => "pets#returns_response_with_invalid_array"
       get "/pets/undocumented_method" => "pets#undocumented_method"
+
+      # generate 1000 routes for testing performance of route matching used by api! method
+      # it's okay that these don't go anywhere real
+      1000.times do |i|
+        get "/api/v1/pets/#{i}" => "pets#{i}#show"
+      end
     end
 
     apipie

data/spec/dummy/config.ru

@@ -1,4 +1,4 @@
 # This file is used by Rack-based servers to start the application.
 
-require ::File.expand_path('../config/environment',  __FILE__)
+require File.expand_path('config/environment',  __dir__)
 run Dummy::Application

data/spec/dummy/script/rails

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 # This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
 
-APP_PATH = File.expand_path('../../config/application',  __FILE__)
-require File.expand_path('../../config/boot',  __FILE__)
+APP_PATH = File.expand_path('../config/application',  __dir__)
+require File.expand_path('../config/boot',  __dir__)
 require 'rails/commands'

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/{extractor → apipie}/extractor_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Apipie::Extractor do
   it 'handles routes without (.:format)' do
-    Apipie::Extractor.apis_from_routes.each do |(controller, action), apis|
+    Apipie::Extractor.apis_from_routes.each_value do |apis|
       apis.each { |api| expect(api[:path]).not_to be_nil }
     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