apipie-rails-jq 1.4.3.pre.beta.pre.jq.1

data/spec/lib/apipie/param_group_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+describe "param groups" do
+  before { Apipie.reload_documentation }
+
+  it "lets reuse the params description in more actions" do
+    user_create_desc = Apipie["users#create"].params[:user]
+    user_create_params = user_create_desc.validator.params_ordered.map(&:name)
+
+    user_update_desc = Apipie["users#update"].params[:user]
+    user_update_params = user_update_desc.validator.params_ordered.map(&:name)
+
+    common = user_update_params & user_create_params
+    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)
+    expect(user_create_params.map(&:to_s).sort).to eq(%w[membership name pass])
+  end
+
+  it "allows 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)
+    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
+      expect(Apipie["users#create"].params[:user].required).to be true
+      expect(Apipie["users#update"].params[:user].required).to be true
+    end
+  end
+
+  it "lets you reuse a group definition from different controller" do
+    arch_v1_desc = Apipie["1.0#architectures#create"].params[:architecture]
+    arch_v1_params = arch_v1_desc.validator.params_ordered.map(&:name)
+
+    arch_v2_desc = Apipie["2.0#architectures#create"].params[:architecture]
+    arch_v2_params = arch_v2_desc.validator.params_ordered.map(&:name)
+
+    expect(arch_v1_params.sort_by(&:to_s)).to eq(arch_v2_params.sort_by(&:to_s))
+  end
+
+  it "replaces parameter name in a group when it comes from concern" do
+    expect(Apipie["overridden_concern_resources#update"].params.key?(:user)).to eq(true)
+  end
+
+  it "does not replace parameter name in a group redefined in the controller" do
+    expect(Apipie["overridden_concern_resources#create"].params.key?(:concern)).to eq(true)
+    expect(Apipie["overridden_concern_resources#create"].params.key?(:user)).to eq(false)
+  end
+
+it "does not replace name of a parameter defined in the controller" do
+    expect(Apipie["overridden_concern_resources#custom"].params.key?(:concern)).to eq(true)
+    expect(Apipie["overridden_concern_resources#custom"].params.key?(:user)).to eq(false)
+  end
+
+end
+

data/spec/lib/apipie/resource_description_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+
+describe Apipie::ResourceDescription do
+  let(:resource_description) do
+    Apipie::ResourceDescription.new(controller, id, dsl_data)
+  end
+
+  let(:controller) { ApplicationController }
+  let(:id) { 'dummy' }
+  let(:dsl_data) { ActionController::Base.send(:_apipie_dsl_data_init) }
+
+  describe '#_methods' do
+    subject(:methods) { resource_description._methods }
+
+    context 'when has method descriptions' do
+      before do
+        resource_description.add_method_description(
+          Apipie::MethodDescription.new(:a, resource_description, dsl_data)
+        )
+        resource_description.add_method_description(
+          Apipie::MethodDescription.new(:b, resource_description, dsl_data)
+        )
+        resource_description.add_method_description(
+          Apipie::MethodDescription.new(:c, resource_description, dsl_data)
+        )
+      end
+
+      it 'is ordered' do
+        expect(methods.keys).to eq([:a, :b, :c])
+      end
+    end
+  end
+
+  describe '#to_json' do
+    let(:json_data) { resource_description.to_json }
+
+    describe 'metadata' do
+      subject { json_data[:metadata] }
+
+      it { is_expected.to be_nil }
+
+      context 'when meta data are provided' do
+        let(:meta) { { length: 32, weight: '830g' } }
+        let(:dsl_data) { super().update({ meta: meta }) }
+
+        it { is_expected.to eq(meta) }
+      end
+    end
+
+    describe 'methods' do
+      subject(:methods_as_json) { json_data[:methods] }
+
+      context 'when has method descriptions' do
+        before do
+          resource_description.add_method_description(
+            Apipie::MethodDescription.new(:a, resource_description, dsl_data)
+          )
+          resource_description.add_method_description(
+            Apipie::MethodDescription.new(:b, resource_description, dsl_data)
+          )
+          resource_description.add_method_description(
+            Apipie::MethodDescription.new(:c, resource_description, dsl_data)
+          )
+        end
+
+        it 'is ordered' do
+          expect(methods_as_json.map { |h| h[:name] }).to eq(%w[a b c])
+        end
+      end
+    end
+  end
+
+  describe 'name' do
+    subject { resource_description.name }
+
+    it { is_expected.to eq('Dummy') }
+
+    context 'when given id contains dashes' do
+      let(:id) { 'some-nested-resource' }
+
+      it { is_expected.to eq('Some::Nested::Resource') }
+    end
+
+    context 'when resource_name is given' do
+      let(:resource_name) { 'Some-Resource' }
+      let(:dsl_data) { super().merge!(resource_name: 'Some-Resource') }
+
+      it { is_expected.to eq(resource_name) }
+    end
+  end
+end

data/spec/lib/apipie/response_description/response_object_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Apipie::ResponseDescription::ResponseObject do
+  describe '#header' do
+    let(:response_object) { described_class.new(nil, nil, nil, nil) }
+    let(:name) { 'Current-Page' }
+    let(:description) { 'The current page in the pagination' }
+
+    before { response_object.header(name, String, description) }
+
+    it 'adds it to the headers' do
+      expect(response_object.headers).to(
+        contain_exactly({
+                          name: name,
+                          description: description,
+                          validator: 'string',
+                          options: {}
+                        })
+      )
+    end
+  end
+end

data/spec/lib/apipie/response_description_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Apipie::ResponseDescription do
+  let(:resource_description) do
+    Apipie::ResourceDescription.new(PetsController, 'pets')
+  end
+
+  let(:method_description) do
+    Apipie::MethodDescription.new(
+      'create',
+      resource_description,
+      ActionController::Base.send(:_apipie_dsl_data_init)
+    )
+  end
+
+  let(:response_description_dsl) { proc {} }
+  let(:options) { {} }
+
+  let(:response_description) do
+    described_class.new(
+      method_description,
+      204,
+      options,
+      PetsController,
+      response_description_dsl,
+      nil
+    )
+  end
+
+  describe '#to_json' do
+    let(:to_json) { response_description.to_json }
+
+    describe 'headers' do
+      subject(:headers) { to_json[:headers] }
+
+      it { is_expected.to be_blank }
+
+      context 'when response has headers' do
+        let(:response_description_dsl) do
+          proc do
+            header 'Current-Page', Integer, 'The current page in the pagination', required: true
+          end
+        end
+
+        it 'returns the header' do
+          expect(headers).to contain_exactly({
+                                               name: 'Current-Page',
+                                               description: 'The current page in the pagination',
+                                               validator: 'integer',
+                                               options: { required: true }
+                                             })
+        end
+      end
+    end
+  end
+end

data/spec/lib/apipie/response_does_not_match_swagger_schema_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Apipie::ResponseDoesNotMatchSwaggerSchema do
+  let(:error) do
+    described_class.new(
+      controller_name,
+      method_name,
+      response_code,
+      error_messages,
+      schema,
+      returned_object
+    )
+  end
+
+  let(:controller_name) { 'UserController' }
+  let(:method_name) { 'index' }
+  let(:response_code) { 200 }
+  let(:error_messages) { [] }
+  let(:schema) { {} }
+  let(:returned_object) { {} }
+
+  describe '#to_s' do
+    subject { error.to_s }
+
+    let(:error_message) do
+      <<~HEREDOC.chomp
+        Response does not match swagger schema (#{controller_name}##{method_name} #{response_code}): #{error_messages}
+        Schema: #{JSON(schema)}
+        Returned object: #{returned_object}
+      HEREDOC
+    end
+
+    it { is_expected.to eq(error_message) }
+  end
+end

data/spec/lib/apipie/swagger_generator_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'dummy/app/controllers/pets_using_self_describing_classes_controller'
+
+describe Apipie::SwaggerGenerator do
+  describe '.json_schema_for_method_response' do
+    subject { json_schema_for_method_response }
+
+    let(:response_description_dsl) do
+      proc do
+        property :a_number, Integer, example: 1
+        property :an_optional_number, Integer, required: false
+      end
+    end
+
+    let(:response_description_options) do
+      [{}, PetsController, response_description_dsl, nil]
+    end
+
+    let(:dsl_data) do
+      ActionController::Base
+        .send(:_apipie_dsl_data_init)
+        .merge(
+          {
+            returns: [[200, response_description_options]],
+            api_args: [
+              ['get', '/path', 'Some api description', { deprecated: true }]
+            ]
+          }
+        )
+    end
+
+    let(:method_description) do
+      Apipie::MethodDescription.new(
+        :show,
+        Apipie::ResourceDescription.new(UsersController, 'users'),
+        dsl_data
+      )
+    end
+
+    let(:json_schema_for_method_response) do
+      described_class.json_schema_for_method_response(
+        method_description,
+        return_code,
+        false
+      )
+    end
+
+    context 'when there is no return code for responses' do
+      let(:return_code) { 3000 }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'when return code exists' do
+      let(:return_code) { 200 }
+
+      describe 'properties' do
+        subject(:properties) { json_schema_for_method_response[:properties] }
+
+        it 'returns correct properties' do
+          expect(properties).to eq(
+            {
+              a_number: {
+                type: 'number', required: true, example: 1
+              },
+              an_optional_number: {
+                type: 'number'
+              }
+            }
+          )
+        end
+      end
+    end
+  end
+
+  describe '.json_schema_for_self_describing_class' do
+    subject(:schema) do
+      described_class.json_schema_for_self_describing_class(
+        self_describing_class,
+        allow_null
+      )
+    end
+
+    let(:self_describing_class) { PetWithMeasurements }
+    let(:allow_null) { false }
+
+    before { Apipie.configuration.generator.swagger.responses_use_refs = false }
+
+    it 'returns the self describing class schema' do
+      expect(schema.keys).to include(:type, :properties, :required)
+      expect(schema[:properties].keys).to include(:pet_name, :animal_type, :pet_measurements)
+    end
+  end
+end

data/spec/lib/apipie/validator_spec.rb

@@ -0,0 +1,149 @@
+require "spec_helper"
+
+describe Apipie::Validator 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
+
+  let(:params_desc) do
+    Apipie::ParamDescription.new(method_desc, :param, nil)
+  end
+
+  describe 'TypeValidator' do
+
+    context "expected type" do
+
+      it "returns hash for type Hash" do
+        validator = Apipie::Validator::TypeValidator.new(params_desc, Hash)
+        expect(validator.expected_type).to eq('hash')
+      end
+
+      it "returns array for type Array" do
+        validator = Apipie::Validator::TypeValidator.new(params_desc, Array)
+        expect(validator.expected_type).to eq('array')
+      end
+
+      it "returns numeric for type Numeric" do
+        validator = Apipie::Validator::TypeValidator.new(params_desc, Numeric)
+        expect(validator.expected_type).to eq('numeric')
+      end
+
+      it "returns string by default" do
+        validator = Apipie::Validator::TypeValidator.new(params_desc, Symbol)
+        expect(validator.expected_type).to eq('string')
+      end
+
+    end
+
+    describe 'NumberValidator' do
+      it 'expects a Numeric type' do
+        validator = Apipie::Validator::BaseValidator.find(params_desc, :number, nil, nil)
+        expect(validator.expected_type).to eq('numeric')
+      end
+    end
+  end
+
+  describe 'BooleanValidator' do
+    let(:validator) do
+      Apipie::Validator::BooleanValidator
+    end
+
+    let(:validator_instance) { validator.new(params_desc) }
+
+    describe '.build' do
+      subject { validator.build(params_desc, argument, nil, nil) }
+
+      context 'when argument is [true, false]' do
+        let(:argument) { [true, false] }
+
+        it { is_expected.to be_an_instance_of(Apipie::Validator::BooleanValidator) }
+      end
+
+      context 'when argument is :bool' do
+        let(:argument) { :bool }
+
+        it { is_expected.to be_an_instance_of(Apipie::Validator::BooleanValidator) }
+      end
+
+      context 'when argument :boolean' do
+        let(:argument) { :boolean }
+
+        it { is_expected.to be_an_instance_of(Apipie::Validator::BooleanValidator) }
+      end
+
+      context 'when argument :booooooooolean' do
+        let(:argument) { :booooooooolean }
+
+        it { is_expected.to be_nil }
+      end
+    end
+
+    describe '#validate' do
+      it "validates by object class" do
+        expect(validator_instance.validate("1")).to be_truthy
+        expect(validator_instance.validate(1)).to be_truthy
+        expect(validator_instance.validate(true)).to be_truthy
+        expect(validator_instance.validate(0)).to be_truthy
+        expect(validator_instance.validate(false)).to be_truthy
+        expect(validator_instance.validate({ 1 => 1 })).to be_falsey
+      end
+    end
+
+    describe '#description' do
+      subject { validator_instance.description }
+
+      it { is_expected.to eq('Must be one of: <code>true</code>, <code>false</code>, <code>1</code>, <code>0</code>.') }
+    end
+  end
+
+  describe 'ArrayClassValidator' do
+    it "validates by object class" do
+      validator = Apipie::Validator::ArrayClassValidator.new(params_desc, [Integer, String])
+      expect(validator.validate("1")).to be_truthy
+      expect(validator.validate(1)).to be_truthy
+      expect(validator.validate({ 1 => 1 })).to be_falsey
+    end
+
+    it "has a valid description" do
+      validator = Apipie::Validator::ArrayClassValidator.new(params_desc, [Float, String])
+      expect(validator.description).to eq('Must be one of: <code>Float</code>, <code>String</code>.')
+    end
+  end
+
+  describe 'RegexpValidator' do
+    it "validates by object class" do
+      validator = Apipie::Validator::RegexpValidator.new(params_desc, /^valid( extra)*$/)
+      expect(validator.validate("valid")).to be_truthy
+      expect(validator.validate("valid extra")).to be_truthy
+      expect(validator.validate("valid extra extra")).to be_truthy
+      expect(validator.validate("invalid")).to be_falsey
+    end
+
+    it "has a valid description" do
+      validator = Apipie::Validator::RegexpValidator.new(params_desc, /^valid( extra)*$/)
+      expect(validator.description).to eq('Must match regular expression <code>/^valid( extra)*$/</code>.')
+    end
+  end
+
+  describe 'EnumValidator' do
+    it "validates by object class" do
+      validator = Apipie::Validator::EnumValidator.new(params_desc, ['first', 'second & third'])
+      expect(validator.validate("first")).to be_truthy
+      expect(validator.validate("second & third")).to be_truthy
+      expect(validator.validate(1)).to be_falsey
+      expect(validator.validate({ 1 => 1 })).to be_falsey
+    end
+
+    it "has a valid description" do
+      validator = Apipie::Validator::EnumValidator.new(params_desc, ['first', 'second & third'])
+      expect(validator.description).to eq('Must be one of: <code>first</code>, <code>second &amp; third</code>.')
+    end
+  end
+end

data/spec/lib/rake_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe 'rake tasks' do
+  include_context "rake"
+
+  let(:doc_path)  { 'tmp/user_specified_doc_path' }
+
+  before do
+    Apipie.configuration.doc_path = doc_path
+    allow(Apipie).to receive(:reload_documentation)
+    subject.invoke(*task_args)
+  end
+
+  describe 'static pages' do
+
+    let(:apidoc_html) do
+      File.read("#{doc_output}.html")
+    end
+
+    let(:doc_output) do
+      File.join(Rails.root, doc_path, 'apidoc')
+    end
+
+    after do
+      Dir["#{doc_output}*"].each { |static_file| FileUtils.rm_rf(static_file) }
+    end
+
+    describe 'apipie:static' do
+      it "generates static files for the default version of apipie docs" do
+        expect(apidoc_html).to match(/Test app #{Apipie.configuration.default_version}/)
+      end
+
+      it "includes the stylesheets" do
+        expect(apidoc_html).to include('./apidoc/stylesheets/bundled/bootstrap.min.css')
+        expect(File).to exist(File.join(doc_output, 'stylesheets/bundled/bootstrap.min.css'))
+      end
+    end
+
+    describe 'apipie:static[2.0]' do
+      it "generates static files for the default version of apipie docs" do
+        expect(apidoc_html).to match(/Test app 2.0/)
+      end
+
+      it "includes the stylesheets" do
+        expect(apidoc_html).to include('./apidoc/stylesheets/bundled/bootstrap.min.css')
+        expect(File).to exist(File.join(doc_output, 'stylesheets/bundled/bootstrap.min.css'))
+      end
+    end
+  end
+
+  describe 'apipie:cache' do
+    let(:cache_output) { Apipie.configuration.cache_dir }
+
+    let(:apidoc_html) do
+      File.read("#{cache_output}.html")
+    end
+
+    after do
+      Dir["#{cache_output}*"].each { |static_file| FileUtils.rm_rf(static_file) }
+    end
+
+    it "generates cache files" do
+      expect(File).to exist(File.join(cache_output, 'apidoc.html'))
+      expect(File).to exist(File.join(cache_output, 'apidoc/development.html'))
+      expect(File).to exist(File.join(cache_output, 'apidoc/development/users.html'))
+
+    end
+  end
+end