apipie-rails 0.9.4 → 1.0.0

data/spec/lib/apipie/param_description_spec.rb

@@ -114,88 +114,210 @@ describe Apipie::ParamDescription do
   end
 
   describe 'validate' do
+    subject { param_description.validate(validation_value) }
+
+    let(:allow_blank) { nil }
+
+    let(:param_description) do
+      Apipie::ParamDescription.new(
+        method_desc,
+        :param,
+        validation_type,
+        allow_blank: allow_blank
+      )
+    end
+
     context 'when allow_blank is ignored, as it was before 0.7.0' do
-      before do
-        Apipie.configuration.ignore_allow_blank_false = true
-      end
+      before { Apipie.configuration.ignore_allow_blank_false = true }
+      after { Apipie.configuration.ignore_allow_blank_false = false }
 
-      context 'when the parameter is a boolean' do
-        it "should not throw an exception when passed false" do
-          expect { Apipie::ParamDescription.new(method_desc, :param, :boolean).validate(false) }.to_not raise_error
+      context 'when validation type is :boolean' do
+        let(:validation_type) { :boolean }
+
+        context 'when validation value is false' do
+          let(:validation_value) { false }
+
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
+          end
         end
 
-        it "should throw an exception when passed an empty value" do
-          expect { Apipie::ParamDescription.new(method_desc, :param, :boolean).validate('') }.to raise_error(Apipie::ParamInvalid)
+        context 'when validation value is an empty string' do
+          let(:validation_value) { '' }
+
+          it 'should raise an error' do
+            expect { subject }.to raise_error(Apipie::ParamInvalid)
+          end
         end
       end
 
-      context 'when the parameter is a string' do
-        context 'when allow_blank is specified as true' do
-          it "should throw an exception when passed an empty value" do
-            expect { Apipie::ParamDescription.new(method_desc, :param, String, allow_blank: true).validate('') }.to_not raise_error
+      context 'when validation type is a boolean array' do
+        let(:validation_type) { [true, false] }
+
+        context 'when validation value is false' do
+          let(:validation_value) { false }
+
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
           end
         end
-        context 'when allow_blank is specified as false' do
-          it "should throw an exception when passed an empty value" do
-            expect { Apipie::ParamDescription.new(method_desc, :param, String, allow_blank: false).validate('') }.to_not raise_error
+
+        context 'when validation value is true' do
+          let(:validation_value) { true }
+
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
           end
         end
-        context 'when allow_blank is not specified' do
-          it "should throw an exception when passed an empty value" do
-            expect { Apipie::ParamDescription.new(method_desc, :param, String).validate('') }.to_not raise_error
+
+        context 'when validation value is an empty string' do
+          let(:validation_value) { '' }
+
+          it 'should raise an error' do
+            expect { subject }.to raise_error(Apipie::ParamInvalid)
           end
         end
       end
 
-      after do
-        Apipie.configuration.ignore_allow_blank_false = false
+      context 'when validation type is String' do
+        let(:validation_type) { String }
+
+        context 'when validation value is empty string' do
+          let(:validation_value) { '' }
+
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
+          end
+
+          context 'when allow_blank is specified as true' do
+            let(:allow_blank) { true }
+
+            it 'should not raise an error' do
+              expect { subject }.not_to raise_error
+            end
+          end
+        end
       end
     end
 
-    context 'when the parameter is a boolean' do
-      it "should not throw an exception when passed false" do
-        expect { Apipie::ParamDescription.new(method_desc, :param, :boolean).validate(false) }.to_not raise_error
-      end
+    context 'when the validation type is :boolean' do
+      let(:validation_type) { :boolean }
+
+      context 'when validation value' do
+        let(:validation_value) { false }
+
+        it 'should not raise an error' do
+          expect { subject }.not_to raise_error
+        end
+
+        context 'when allow_blank is false' do
+          let(:allow_blank) { false }
+
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
+          end
+        end
+
+        context 'when allow_blank is true' do
+          let(:allow_blank) { true }
 
-      it "should still not throw an exception when passed false with explicit allow_blank: false" do
-        expect { Apipie::ParamDescription.new(method_desc, :param, :boolean, allow_blank: false).validate(false) }.to_not raise_error
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
+          end
+        end
       end
 
-      it "should throw an exception when passed an empty value" do
-        expect { Apipie::ParamDescription.new(method_desc, :param, :boolean).validate('') }.to raise_error(Apipie::ParamInvalid)
+      context 'when validation value is empty string' do
+        let(:validation_value) { '' }
+
+        it 'should raise an error' do
+          expect { subject }.to raise_error(Apipie::ParamInvalid)
+        end
       end
     end
 
-    context "when the parameter is a custom type with ignore_allow_blank? returning true" do
-      it "should not throw an exception when passed a blank but valid value" do
-        expect { Apipie::ParamDescription.new(method_desc, :param, :custom_bool).validate(false) }.to_not raise_error
+    context 'when validation type is a boolean array' do
+      let(:validation_type) { [true, false] }
+
+      context 'when validation value is false' do
+        let(:validation_value) { false }
+
+        it 'should not raise an error' do
+          expect { subject }.not_to raise_error
+        end
       end
 
-      it "should still not throw an exception when passed false with explicit allow_blank: false" do
-        expect { Apipie::ParamDescription.new(method_desc, :param, :custom_bool, allow_blank: false).validate(false) }.to_not raise_error
+      context 'when validation value is true' do
+        let(:validation_value) { true }
+
+        it 'should not raise an error' do
+          expect { subject }.not_to raise_error
+        end
       end
 
-      it "should throw an exception when passed an invalid but blank value" do
-        expect { Apipie::ParamDescription.new(method_desc, :param, :custom_bool).validate("") }.to raise_error(Apipie::ParamInvalid)
+      context 'when validation value is an empty string' do
+        let(:validation_value) { '' }
+
+        it 'should raise an error' do
+          expect { subject }.to raise_error(Apipie::ParamInvalid)
+        end
       end
     end
 
-    context 'when the parameter is a string' do
-      context 'when allow_blank is specified as true' do
-        it "should throw an exception when passed an empty value" do
-          expect { Apipie::ParamDescription.new(method_desc, :param, String, allow_blank: true).validate('') }.to_not raise_error
+    context 'when the validation type is a custom one' do
+      let(:validation_type) { :custom_bool }
+
+      context 'when ignore_allow_blank? returning true' do
+        before do
+          allow(CustomBoolValidator).to receive(:ignore_allow_blank?).and_return(true)
+        end
+
+        context 'when a blank but valid value is passed' do
+          let(:validation_value) { false }
+
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
+          end
+
+          context 'when allow_blank is false' do
+            let(:allow_blank) { false }
+
+            it 'should not raise an error' do
+              expect { subject }.not_to raise_error
+            end
+          end
+        end
+
+        context 'when a blank but invalid value is passed' do
+          let(:validation_value) { '' }
+
+          it 'should raise an error' do
+            expect { subject }.to raise_error(Apipie::ParamInvalid)
+          end
         end
       end
-      context 'when allow_blank is specified as false' do
-        it "should throw an exception when passed an empty value" do
-          expect do
-            Apipie::ParamDescription.new(method_desc, :param, String, allow_blank: false).validate('')
-          end.to raise_error(Apipie::ParamInvalid)
+    end
+
+    context 'when validation type is String' do
+      let(:validation_type) { String }
+
+      context 'when a blank but invalid value is passed' do
+        let(:validation_value) { '' }
+
+        it 'should raise an error' do
+          expect { subject }.to raise_error(Apipie::ParamInvalid)
         end
       end
-      context 'when allow_blank is not specified' do
-        it "should throw an exception when passed an empty value" do
-          expect { Apipie::ParamDescription.new(method_desc, :param, String).validate('') }.to raise_error(Apipie::ParamInvalid)
+
+      context 'when allow_blank is specified as true' do
+        let(:allow_blank) { true }
+
+        context 'when and empty string is given' do
+          let(:validation_value) { '' }
+
+          it 'should not raise an error' do
+            expect { subject }.not_to raise_error
+          end
         end
       end
     end
@@ -239,7 +361,6 @@ describe Apipie::ParamDescription do
     end
   end
 
-
   describe "required_by_default config option" do
     context "parameters required by default" do
 
@@ -369,7 +490,6 @@ describe Apipie::ParamDescription do
     end
   end
 
-
   describe 'sub params' do
 
     context 'with HashValidator' do
@@ -508,4 +628,44 @@ describe Apipie::ParamDescription do
     end
   end
 
+  describe '#required' do
+    subject { param_description.required }
+
+    let(:param_description) do
+      Apipie::ParamDescription.new(method_desc, :param, validator, options)
+    end
+
+    context 'when is passed in options' do
+      let(:validator) { String }
+
+      context 'when is false' do
+        let(:options) { { required: false } }
+
+        it { is_expected.to eq(false) }
+      end
+
+      context 'when is true' do
+        let(:options) { { required: true } }
+
+        it { is_expected.to eq(true) }
+      end
+    end
+
+    context 'when validator options are passed' do
+      let(:options) { { only_in: :response } }
+      let(:validator) { { array_of: String, required: required } }
+
+      context 'when required is false' do
+        let(:required) { false }
+
+        it { is_expected.to eq(false) }
+      end
+
+      context 'when required is true' do
+        let(:required) { true }
+
+        it { is_expected.to eq(true) }
+      end
+    end
+  end
 end

data/spec/lib/apipie/param_group_spec.rb

@@ -1,6 +1,7 @@
 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]

data/spec/lib/apipie/resource_description_spec.rb

@@ -64,7 +64,7 @@ describe Apipie::ResourceDescription do
         end
 
         it 'should be ordered' do
-          expect(methods_as_json.map { |h| h[:name] }).to eq(['a', 'b', 'c'])
+          expect(methods_as_json.map { |h| h[:name] }).to eq(%w[a b c])
         end
       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
+        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'
+              },
+              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

@@ -51,19 +51,55 @@ describe Apipie::Validator do
   end
 
   describe 'BooleanValidator' do
-    it "should validate by object class" do
-      validator = Apipie::Validator::BooleanValidator.new(params_desc)
-      expect(validator.validate("1")).to be_truthy
-      expect(validator.validate(1)).to be_truthy
-      expect(validator.validate(true)).to be_truthy
-      expect(validator.validate(0)).to be_truthy
-      expect(validator.validate(false)).to be_truthy
-      expect(validator.validate({ 1 => 1 })).to be_falsey
+    let(:validator) do
+      Apipie::Validator::BooleanValidator
     end
 
-    it "should have a valid description" do
-      validator = Apipie::Validator::BooleanValidator.new(params_desc)
-      expect(validator.description).to eq('Must be one of: <code>true</code>, <code>false</code>, <code>1</code>, <code>0</code>.')
+    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 "should validate 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
 

data/spec/lib/swagger/rake_swagger_spec.rb

@@ -12,7 +12,7 @@ describe 'rake tasks' do
 
   before do
     Apipie.configuration.doc_path = doc_path
-    Apipie.configuration.swagger_suppress_warnings = true
+    Apipie.configuration.generator.swagger.suppress_warnings = true
     allow(Apipie).to receive(:reload_documentation)
     subject.invoke(*task_args)
   end
@@ -102,7 +102,7 @@ describe 'rake tasks' do
 
         expect_param_def("get", "/users/by_department", "department", "in", "query")
         expect_param_def("get", "/users/by_department", "department", "enum",
-                         ["finance", "operations", "sales", "marketing", "HR"])
+                         %w[finance operations sales marketing HR])
 
         expect_tags_def("get", "/twitter_example/{id}/followers", %w[twitter_example following index search])
       end
@@ -128,11 +128,11 @@ describe 'rake tasks' do
         expect_param_def("put", "/users/{id}", "oauth", "in", "formData")
         expect_param_def("get", "/users/by_department", "department", "in", "query")
         expect_param_def("get", "/users/by_department", "department", "enum",
-                         ["finance", "operations", "sales", "marketing", "HR"])
+                         %w[finance operations sales marketing HR])
 
         expect_param_def("get", "/users/in_departments", "departments", "in", "query")
         expect_array_param_def("get", "/users/in_departments", "departments",
-                         ["finance", "operations", "sales", "marketing", "HR"])
+                         %w[finance operations sales marketing HR])
 
         expect_tags_def("get", "/twitter_example/{id}/followers", %w[twitter_example following index search])
 

data/spec/lib/swagger/swagger_dsl_spec.rb

@@ -6,7 +6,7 @@ describe "Swagger Responses" do
   let(:desc) { Apipie.get_resource_description(controller_class, Apipie.configuration.default_version) }
 
   let(:swagger) {
-    Apipie.configuration.swagger_suppress_warnings = true
+    Apipie.configuration.generator.swagger.suppress_warnings = true
     Apipie.to_swagger_json(Apipie.configuration.default_version, controller_class.to_s.underscore.sub("_controller", ""))
   }
 
@@ -141,7 +141,7 @@ describe "Swagger Responses" do
 
         a_schema = resolve_refs(schema[:items])
         expect(a_schema).to have_field(:pet_name, 'string', {:description => 'Name of pet', :required => false})
-        expect(a_schema).to have_field(:animal_type, 'string', {:description => 'Type of pet', :enum => ['dog','cat','iguana','kangaroo']})
+        expect(a_schema).to have_field(:animal_type, 'string', {:description => 'Type of pet', :enum => %w[dog cat iguana kangaroo]})
       end
 
 
@@ -210,7 +210,7 @@ describe "Swagger Responses" do
 
         schema = response[:schema]
         expect(schema).to have_field(:pet_name, 'string', {:description => 'Name of pet', :required => false})
-        expect(schema).to have_field(:animal_type, 'string', {:description => 'Type of pet', :enum => ['dog','cat','iguana','kangaroo']})
+        expect(schema).to have_field(:animal_type, 'string', {:description => 'Type of pet', :enum => %w[dog cat iguana kangaroo]})
       end
 
       it 'should have the 404 response description overridden' do
@@ -247,7 +247,7 @@ describe "Swagger Responses" do
 
         schema = response[:schema]
         expect(schema).to have_field(:pet_name, 'string', {:description => 'Name of pet', :required => false})
-        expect(schema).to have_field(:animal_type, 'string', {:description => 'Type of pet', :enum => ['dog','cat','iguana','kangaroo']})
+        expect(schema).to have_field(:animal_type, 'string', {:description => 'Type of pet', :enum => %w[dog cat iguana kangaroo]})
       end
     end
 
@@ -282,7 +282,7 @@ describe "Swagger Responses" do
         schema = response[:schema]
         expect(schema).to have_field(:pet_id, 'number', {:description => 'id of pet'})
         expect(schema).to have_field(:pet_name, 'string', {:description => 'Name of pet', :required => false})
-        expect(schema).to have_field(:animal_type, 'string', {:description => 'Type of pet', :enum => ['dog','cat','iguana','kangaroo']})
+        expect(schema).to have_field(:animal_type, 'string', {:description => 'Type of pet', :enum => %w[dog cat iguana kangaroo]})
         expect(schema).not_to have_field(:partial_match_allowed, 'boolean', {:required => false})
       end
 
@@ -433,7 +433,7 @@ describe "Swagger Responses" do
 
         schema = response[:schema]
         expect(schema).to have_field(:int_array, 'array', {items: {type: 'number'}})
-        expect(schema).to have_field(:enum_array, 'array', {items: {type: 'string', enum: ['v1','v2','v3']}})
+        expect(schema).to have_field(:enum_array, 'array', {items: {type: 'string', enum: %w[v1 v2 v3]}})
       end
 
 
@@ -551,7 +551,7 @@ describe "Swagger Responses" do
 
         a_schema = schema[:items]
         expect(a_schema).to have_field(:pet_name, 'string', {:description => 'Name of pet', :required => false})
-        expect(a_schema).to have_field(:animal_type, 'string', {:description => 'Type of pet', :enum => ['dog','cat','iguana','kangaroo']})
+        expect(a_schema).to have_field(:animal_type, 'string', {:description => 'Type of pet', :enum => %w[dog cat iguana kangaroo]})
       end
     end
 

data/spec/lib/validators/array_validator_spec.rb

@@ -30,7 +30,7 @@ module Apipie::Validator
         let(:type) { String }
 
         it "accepts array of specified type" do
-          expect(validator.validate(['string1', 'string2'])).to eq(true)
+          expect(validator.validate(%w[string1 string2])).to eq(true)
         end
 
         it "accepts empty array" do