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

data/spec/lib/validators/array_validator_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+module Apipie::Validator
+  describe ArrayValidator do
+
+    let(:param_desc) { double(:param_desc) }
+
+    context "with no constraint" do
+      let(:validator) { ArrayValidator.new(param_desc, Array) }
+      it "accepts any array" do
+        expect(validator.validate([42, 'string', true])).to eq(true)
+      end
+
+      it "accepts empty array" do
+        expect(validator.validate([])).to eq(true)
+        expect(validator.validate(nil)).to eq(true)
+      end
+
+      it "does not accepts non array" do
+        expect(validator.validate(42)).to eq(false)
+        expect(validator.validate(true)).to eq(false)
+        expect(validator.validate('string')).to eq(false)
+      end
+    end
+
+    context "with a constraint on items type" do
+      let(:validator) { ArrayValidator.new(param_desc, Array, :of => type) }
+
+      context "String" do
+        let(:type) { String }
+
+        it "accepts array of specified type" do
+          expect(validator.validate(%w[string1 string2])).to eq(true)
+        end
+
+        it "accepts empty array" do
+          expect(validator.validate([])).to eq(true)
+        end
+
+        it "does not accepts array with other types" do
+          expect(validator.validate(['string1', true])).to eq(false)
+        end
+      end
+
+      context ":number" do
+        let(:type) { :decimal }
+
+        it "accepts array of specified type" do
+          expect(validator.validate([12, '14'])).to eq(true)
+        end
+
+        it "accepts empty array" do
+          expect(validator.validate([])).to eq(true)
+        end
+
+        it "does not accepts array with other types" do
+          expect(validator.validate([12, 'potato'])).to eq(false)
+        end
+      end
+    end
+
+    context "with a constraint on items value" do
+      let(:validator) { ArrayValidator.new(param_desc, Array, :in => [42, 'string', true]) }
+
+      it "accepts array of valid values" do
+        expect(validator.validate([42, 'string'])).to eq(true)
+      end
+
+      it "accepts empty array" do
+        expect(validator.validate([])).to eq(true)
+      end
+
+      it "does not accepts array with invalid values" do
+        expect(validator.validate([42, 'string', 'foo'])).to eq(false)
+      end
+
+      it "accepts a proc as list of valid values" do
+        validator = ArrayValidator.new(param_desc, Array, :in => lambda { [42, 'string', true] })
+        expect(validator.validate([42, 'string'])).to eq(true)
+        expect(validator.validate([42, 'string', 'foo'])).to eq(false)
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,92 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'simplecov'
+SimpleCov.minimum_coverage 91
+SimpleCov.start
+
+ENV["RAILS_ENV"] ||= 'test'
+APIPIE_ROOT = File.expand_path('..', __dir__)
+require File.expand_path('dummy/config/environment', __dir__)
+
+require 'rspec/rails'
+
+require 'apipie-rails'
+require 'test_engine'
+
+#
+# Matcher to validate the properties (name, type and options) of a single field in the
+# internal representation of a swagger schema
+#
+# For example, code such as:
+#       schema = swagger[:paths][<path>][<method>][:responses][<code>][:schema]
+#       expect(schema).to have_field(:pet_name, 'string', {:required => false})
+#
+# will verify that the selected response schema includes a required string field called 'pet_name'
+#
+RSpec::Matchers.define :have_field do |name, type, opts = {}|
+  def fail(msg)
+    @fail_message = msg
+    false
+  end
+
+  @fail_message = ""
+
+  failure_message do |actual|
+    @fail_message
+  end
+
+  match do |unresolved|
+    actual = resolve_refs(unresolved)
+    return fail("expected schema to have type 'object' (got '#{actual[:type]}')") if actual[:type] != 'object'
+    return fail("expected schema to include param named '#{name}' (got #{actual[:properties].keys})") if (prop = actual[:properties][name]).nil?
+    return fail("expected param '#{name}' to have type '#{type}' (got '#{prop[:type]}')") if prop[:type] != type
+    return fail("expected param '#{name}' to have description '#{opts[:description]}' (got '#{prop[:description]}')") if opts[:description] && prop[:description] != opts[:description]
+    return fail("expected param '#{name}' to have enum '#{opts[:enum]}' (got #{prop[:enum]})") if opts[:enum] && prop[:enum] != opts[:enum]
+    return fail("expected param '#{name}' to have items '#{opts[:items]}' (got #{prop[:items]})") if opts[:items] && prop[:items] != opts[:items]
+    if !opts.include?(:required) || opts[:required] == true
+      return fail("expected param '#{name}' to be required") unless actual[:required].include?(name)
+    else
+      return fail("expected param '#{name}' to be optional") if actual[:required].include?(name)
+    end
+    true
+  end
+end
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.expand_path('support/**/*.rb', __dir__)].sort.each {|f| require f}
+
+RSpec.configure do |config|
+
+  config.mock_with :rspec
+
+  if Rails.version >= "7.1"
+    config.fixture_paths = ["#{Rails.root}/spec/fixtures"]
+  else
+    config.fixture_path = "#{Rails.root}/spec/fixtures"
+  end
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  # If true, the base class of anonymous controllers will be inferred
+  # automatically. This will be the default behavior in future versions of
+  # rspec-rails.
+  config.infer_base_class_for_anonymous_controllers = false
+
+  # rspec-rails 3 will no longer automatically infer an example group's spec type
+  # from the file location. You can explicitly opt-in to the feature using this
+  # config option.
+  # To explicitly tag specs without using automatic inference, set the `:type`
+  # metadata manually:
+  #
+  #     describe ThingsController, :type => :controller do
+  #       # Equivalent to being in spec/controllers
+  #     end
+  config.infer_spec_type_from_file_location!
+end
+
+require 'action_controller/test_case'

data/spec/support/custom_bool_validator.rb

@@ -0,0 +1,17 @@
+class CustomBoolValidator < Apipie::Validator::BaseValidator
+  def validate(value)
+    value.in?([true, false])
+  end
+
+  def self.build(param_description, argument, options, block)
+    new(param_description) if argument == :custom_bool
+  end
+
+  def description
+    "Must be a boolean."
+  end
+
+  def ignore_allow_blank?
+    true
+  end
+end

data/spec/support/rake.rb

@@ -0,0 +1,21 @@
+require "rake"
+
+# inspired by http://robots.thoughtbot.com/test-rake-tasks-like-a-boss
+shared_context "rake" do
+  let(:rake)      { Rake::Application.new }
+  let(:task_name) { rake.parse_task_string(self.class.description).first }
+  let(:task_args) { rake.parse_task_string(self.class.description).last }
+  let(:task_path) { "lib/tasks/apipie" }
+  subject         { rake[task_name] }
+
+  def loaded_files_excluding_current_rake_file
+    $".reject {|file| file == File.expand_path("#{task_path}.rake", APIPIE_ROOT) }
+  end
+
+  before do
+    Rake.application = rake
+    Rake.application.rake_require(task_path, [APIPIE_ROOT], loaded_files_excluding_current_rake_file)
+
+    Rake::Task.define_task(:environment)
+  end
+end

data/spec/test_engine/memes_controller_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe TestEngine::MemesController do
+
+  describe "#index" do
+    it "has the full mounted path of engine" do
+      expect(Apipie.routes_for_action(TestEngine::MemesController, :index, {}).first[:path]).to eq("/test/memes")
+    end
+  end
+end