rails_admin 0.6.1 → 0.6.2

data/spec/rails_admin/adapters/mongoid/property_spec.rb

@@ -0,0 +1,220 @@
+require 'spec_helper'
+
+describe 'RailsAdmin::Adapters::Mongoid::Property', mongoid: true do
+  subject { RailsAdmin::AbstractModel.new(FieldTest).properties.detect { |p| p.name == field } }
+
+  describe '_id field' do
+    let(:field) { :_id }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq ' id'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_true
+      expect(subject.type).to eq :bson_object_id
+      expect(subject.length).to be_nil
+    end
+  end
+
+  describe 'array field' do
+    let(:field) { :array_field }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq 'Array field'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_false
+      expect(subject.type).to eq :serialized
+      expect(subject.length).to be_nil
+    end
+  end
+
+  describe 'big decimal field' do
+    let(:field) { :big_decimal_field }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq 'Big decimal field'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_false
+      expect(subject.type).to eq :decimal
+      expect(subject.length).to be_nil
+    end
+  end
+
+  describe 'boolean field' do
+    let(:field) { :boolean_field }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq 'Boolean field'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_false
+      expect(subject.type).to eq :boolean
+      expect(subject.length).to be_nil
+    end
+  end
+
+  describe 'bson object id field' do
+    let(:field) { :bson_object_id_field }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq 'Bson object id field'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_false
+      expect(subject.type).to eq :bson_object_id
+      expect(subject.length).to be_nil
+    end
+  end
+
+  describe 'date field' do
+    let(:field) { :date_field }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq 'Date field'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_false
+      expect(subject.type).to eq :date
+      expect(subject.length).to be_nil
+    end
+  end
+
+  describe 'datetime field' do
+    let(:field) { :datetime_field }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq 'Datetime field'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_false
+      expect(subject.type).to eq :datetime
+      expect(subject.length).to be_nil
+    end
+  end
+
+  describe 'time with zone field' do
+    let(:field) { :time_with_zone_field }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq 'Time with zone field'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_false
+      expect(subject.type).to eq :datetime
+      expect(subject.length).to be_nil
+    end
+  end
+
+  describe 'default field' do
+    let(:field) { :default_field }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq 'Default field'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_false
+      expect(subject.type).to eq :string
+      expect(subject.length).to eq 255
+    end
+  end
+
+  describe 'float field' do
+    let(:field) { :float_field }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq 'Float field'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_false
+      expect(subject.type).to eq :float
+      expect(subject.length).to be_nil
+    end
+  end
+
+  describe 'hash field' do
+    let(:field) { :hash_field }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq 'Hash field'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_false
+      expect(subject.type).to eq :serialized
+      expect(subject.length).to be_nil
+    end
+  end
+
+  describe 'integer field' do
+    let(:field) { :integer_field }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq 'Integer field'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_false
+      expect(subject.type).to eq :integer
+      expect(subject.length).to be_nil
+    end
+  end
+
+  describe 'object field' do
+    let(:field) { :object_field }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq 'Object field'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_false
+      expect(subject.type).to eq :string
+      expect(subject.length).to eq 255
+    end
+  end
+
+  describe 'string field' do
+    let(:field) { :string_field }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq 'String field'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_false
+      expect(subject.type).to eq :text
+      expect(subject.length).to be_nil
+    end
+  end
+
+  describe 'symbol field' do
+    let(:field) { :symbol_field }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq 'Symbol field'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_false
+      expect(subject.type).to eq :string
+      expect(subject.length).to eq 255
+    end
+  end
+
+  describe 'time field' do
+    let(:field) { :time_field }
+
+    it 'has correct values' do
+      expect(subject.pretty_name).to eq 'Time field'
+      expect(subject.nullable?).to be_true
+      expect(subject.serial?).to be_false
+      expect(subject.type).to eq :datetime
+      expect(subject.length).to be_nil
+    end
+  end
+
+  describe '#length_validation_lookup' do
+    it 'detects validation length properly' do
+      class LengthValiated
+        include Mongoid::Document
+        field :text, type: String
+        validates :text, length: {maximum: 50}
+      end
+      expect(RailsAdmin::AbstractModel.new('LengthValiated').properties.last.send(:length_validation_lookup)).to eq(50)
+    end
+
+    it 'does not cause problem with custom validators' do
+      class MyCustomValidator < ActiveModel::Validator
+        def validate(r); end
+      end
+      class CustomValiated
+        include Mongoid::Document
+        field :text, type: String
+        validates_with MyCustomValidator
+      end
+      expect(lambda { RailsAdmin::AbstractModel.new('CustomValiated').properties.last.send(:length_validation_lookup) }).not_to raise_error
+    end
+  end
+end

data/spec/rails_admin/adapters/mongoid_spec.rb

@@ -1,446 +1,21 @@
 require 'spec_helper'
-require 'timecop'
 
 describe 'RailsAdmin::Adapters::Mongoid', mongoid: true do
   describe '#associations' do
-    before :all do
-      RailsAdmin::AbstractModel.reset_polymorphic_parents
-
-      class MongoBlog
-        include Mongoid::Document
-        has_many :mongo_posts
-        has_many :mongo_comments, as: :commentable
-        belongs_to :librarian, polymorphic: true
-        field :mongo_blog_id
-      end
-
-      class MongoPost
-        include Mongoid::Document
-        belongs_to :mongo_blog
-        has_and_belongs_to_many :mongo_categories
-        has_many :mongo_comments, as: :commentable
-        embeds_one :mongo_note
-        accepts_nested_attributes_for :mongo_note
-      end
-
-      class MongoCategory
-        include Mongoid::Document
-        has_and_belongs_to_many :mongo_posts
-        belongs_to :librarian, polymorphic: true
-      end
-
-      class MongoUser
-        include Mongoid::Document
-        has_one :mongo_profile
-        has_many :mongo_categories, as: :librarian
-
-        embeds_many :mongo_notes
-        accepts_nested_attributes_for :mongo_notes
-        field :name, type: String
-        field :message, type: String
-        field :short_text, type: String
-
-        validates :short_text, length: {maximum: 255}
-      end
-
-      class MongoProfile
-        include Mongoid::Document
-        belongs_to :mongo_user
-        has_many :mongo_blogs, as: :librarian
-      end
-
-      class MongoComment
-        include Mongoid::Document
-        belongs_to :commentable, polymorphic: true
-      end
-
-      class MongoNote
-        include Mongoid::Document
-        embedded_in :mongo_post
-        embedded_in :mongo_user
-      end
-
-      @blog     = RailsAdmin::AbstractModel.new MongoBlog
-      @post     = RailsAdmin::AbstractModel.new MongoPost
-      @category = RailsAdmin::AbstractModel.new MongoCategory
-      @user     = RailsAdmin::AbstractModel.new MongoUser
-      @profile  = RailsAdmin::AbstractModel.new MongoProfile
-      @comment  = RailsAdmin::AbstractModel.new MongoComment
-    end
-
-    after :all do
-      RailsAdmin::AbstractModel.reset_polymorphic_parents
-    end
-
-    it 'lists associations' do
-      expect(@post.associations.collect { |a| a[:name] }).to match_array [:mongo_blog, :mongo_categories, :mongo_comments, :mongo_note]
-    end
-
-    it 'reads correct and know types in [:belongs_to, :has_and_belongs_to_many, :has_many, :has_one]' do
-      expect((@post.associations + @blog.associations + @user.associations).collect { |a|a[:type].to_s }.uniq).to match_array %w(belongs_to has_and_belongs_to_many has_many has_one)
-    end
-
-    it 'has correct parameter of belongs_to association' do
-      param = @post.associations.detect { |a| a[:name] == :mongo_blog }
-      expect(param.reject { |k, v| [:primary_key_proc, :model_proc].include? k }).to eq(
-        name: :mongo_blog,
-        pretty_name: 'Mongo blog',
-        type: :belongs_to,
-        foreign_key: :mongo_blog_id,
-        foreign_type: nil,
-        foreign_inverse_of: nil,
-        as: nil,
-        polymorphic: false,
-        inverse_of: nil,
-        read_only: nil,
-        nested_form: nil
-      )
-      expect(param[:primary_key_proc].call).to eq(:_id)
-      expect(param[:model_proc].call).to eq(MongoBlog)
-    end
-
-    it 'has correct parameter of has_many association' do
-      param = @blog.associations.detect { |a| a[:name] == :mongo_posts }
-      expect(param.reject { |k, v| [:primary_key_proc, :model_proc].include? k }).to eq(
-        name: :mongo_posts,
-        pretty_name: 'Mongo posts',
-        type: :has_many,
-        foreign_key: :mongo_blog_id,
-        foreign_type: nil,
-        foreign_inverse_of: nil,
-        as: nil,
-        polymorphic: false,
-        inverse_of: nil,
-        read_only: nil,
-        nested_form: nil
-      )
-      expect(param[:primary_key_proc].call).to eq(:_id)
-      expect(param[:model_proc].call).to eq(MongoPost)
-      expect(@post.properties.detect { |f| f[:name] == :mongo_blog_id }[:type]).to eq(:bson_object_id)
-    end
-
-    it 'does not confuse foreign_key column which belongs to associated model' do
-      expect(@blog.properties.detect { |f| f[:name] == :mongo_blog_id }[:type]).to eq(:string)
-    end
-
-    it 'has correct parameter of has_and_belongs_to_many association' do
-      param = @post.associations.detect { |a| a[:name] == :mongo_categories }
-      expect(param.reject { |k, v| [:primary_key_proc, :model_proc].include? k }).to eq(
-        name: :mongo_categories,
-        pretty_name: 'Mongo categories',
-        type: :has_and_belongs_to_many,
-        foreign_key: :mongo_category_ids,
-        foreign_type: nil,
-        foreign_inverse_of: nil,
-        as: nil,
-        polymorphic: false,
-        inverse_of: nil,
-        read_only: nil,
-        nested_form: nil
-      )
-      expect(param[:primary_key_proc].call).to eq(:_id)
-      expect(param[:model_proc].call).to eq(MongoCategory)
-    end
-
-    it 'has correct parameter of polymorphic belongs_to association' do
-      allow(RailsAdmin::Config).to receive(:models_pool).and_return(%w(MongoBlog MongoPost MongoCategory MongoUser MongoProfile MongoComment))
-      param = @comment.associations.detect { |a| a[:name] == :commentable }
-      expect(param.reject { |k, v| [:primary_key_proc, :model_proc].include? k }).to eq(
-        name: :commentable,
-        pretty_name: 'Commentable',
-        type: :belongs_to,
-        foreign_key: :commentable_id,
-        foreign_type: :commentable_type,
-        foreign_inverse_of: nil,
-        as: nil,
-        polymorphic: true,
-        inverse_of: nil,
-        read_only: nil,
-        nested_form: nil
-      )
-      expect(param[:primary_key_proc].call).to eq(:_id)
-      expect(param[:model_proc].call).to eq([MongoBlog, MongoPost])
-    end
-
-    it 'has correct parameter of polymorphic inverse has_many association' do
-      allow(RailsAdmin::Config).to receive(:models_pool).and_return(%w(MongoBlog MongoPost MongoCategory MongoUser MongoProfile MongoComment))
-      param = @blog.associations.detect { |a| a[:name] == :mongo_comments }
-      expect(param.reject { |k, v| [:primary_key_proc, :model_proc].include? k }).to eq(
-        name: :mongo_comments,
-        pretty_name: 'Mongo comments',
-        type: :has_many,
-        foreign_key: :commentable_id,
-        foreign_type: nil,
-        foreign_inverse_of: nil,
-        as: :commentable,
-        polymorphic: false,
-        inverse_of: nil,
-        read_only: nil,
-        nested_form: nil
-      )
-      expect(param[:primary_key_proc].call).to eq(:_id)
-      expect(param[:model_proc].call).to eq(MongoComment)
-    end
-
-    it 'has correct opposite model lookup for polymorphic associations' do
-      allow(RailsAdmin::Config).to receive(:models_pool).and_return(%w(MongoBlog MongoPost MongoCategory MongoUser MongoProfile MongoComment))
-      expect(@category.associations.detect { |a| a[:name] == :librarian }[:model_proc].call).to eq [MongoUser]
-      expect(@blog.associations.detect { |a| a[:name] == :librarian }[:model_proc].call).to eq [MongoProfile]
-    end
-
-    it 'has correct parameter of embeds_one association' do
-      param = @post.associations.detect { |a| a[:name] == :mongo_note }
-      expect(param.reject { |k, v| [:primary_key_proc, :model_proc].include? k }).to eq(
-        name: :mongo_note,
-        pretty_name: 'Mongo note',
-        type: :has_one,
-        foreign_key: nil,
-        foreign_type: nil,
-        foreign_inverse_of: nil,
-        as: nil,
-        polymorphic: false,
-        inverse_of: nil,
-        read_only: nil,
-        nested_form: {allow_destroy: false, update_only: false}
-      )
-      expect(param[:primary_key_proc].call).to eq(:_id)
-      expect(param[:model_proc].call).to eq(MongoNote)
-    end
-
-    it 'has correct parameter of embeds_many association' do
-      param = @user.associations.detect { |a| a[:name] == :mongo_notes }
-      expect(param.reject { |k, v| [:primary_key_proc, :model_proc].include? k }).to eq(
-        name: :mongo_notes,
-        pretty_name: 'Mongo notes',
-        type: :has_many,
-        foreign_key: nil,
-        foreign_type: nil,
-        foreign_inverse_of: nil,
-        as: nil,
-        polymorphic: false,
-        inverse_of: nil,
-        read_only: nil,
-        nested_form: {allow_destroy: false, update_only: false}
-      )
-      expect(param[:primary_key_proc].call).to eq(:_id)
-      expect(param[:model_proc].call).to eq(MongoNote)
-    end
-
-    it 'raises error when embeds_* is used without accepts_nested_attributes_for' do
-      class MongoEmbedsOne
-        include Mongoid::Document
-        embeds_one :mongo_embedded
-      end
-
-      class MongoEmbedsMany
-        include Mongoid::Document
-        embeds_many :mongo_embeddeds
-      end
-
-      class MongoEmbedded
-        include Mongoid::Document
-        embedded_in :mongo_embeds_one
-        embedded_in :mongo_embeds_many
-      end
-
-      class MongoRecursivelyEmbedsOne
-        include Mongoid::Document
-        recursively_embeds_one
-      end
-
-      class MongoRecursivelyEmbedsMany
-        include Mongoid::Document
-        recursively_embeds_many
-      end
-
-      expect(lambda { RailsAdmin::AbstractModel.new(MongoEmbedsOne).associations }).to raise_error(RuntimeError,
-                                                                                                   "Embbeded association without accepts_nested_attributes_for can't be handled by RailsAdmin,\nbecause embedded model doesn't have top-level access.\nPlease add `accepts_nested_attributes_for :mongo_embedded' line to `MongoEmbedsOne' model.\n"
-      )
-      expect(lambda { RailsAdmin::AbstractModel.new(MongoEmbedsMany).associations }).to raise_error(RuntimeError,
-                                                                                                    "Embbeded association without accepts_nested_attributes_for can't be handled by RailsAdmin,\nbecause embedded model doesn't have top-level access.\nPlease add `accepts_nested_attributes_for :mongo_embeddeds' line to `MongoEmbedsMany' model.\n"
-      )
-      expect(lambda { RailsAdmin::AbstractModel.new(MongoRecursivelyEmbedsOne).associations }).not_to raise_error
-      expect(lambda { RailsAdmin::AbstractModel.new(MongoRecursivelyEmbedsMany).associations }).not_to raise_error
-    end
-
-    it 'works with inherited embeds_many model' do
-      class MongoEmbedsParent
-        include Mongoid::Document
-        embeds_many :mongo_embeddeds
-        accepts_nested_attributes_for :mongo_embeddeds
-      end
-
-      class MongoEmbedded
-        include Mongoid::Document
-        embedded_in :mongo_embeds_many
-      end
-
-      class MongoEmbedsChild < MongoEmbedsParent; end
-
-      expect(lambda { RailsAdmin::AbstractModel.new(MongoEmbedsChild).associations }).not_to raise_error
+    it 'returns Association class' do
+      expect(RailsAdmin::AbstractModel.new(Player).associations.first).
+        to be_a_kind_of RailsAdmin::Adapters::Mongoid::Association
     end
   end
 
   describe '#properties' do
-    before :all do
-      @abstract_model = RailsAdmin::AbstractModel.new(FieldTest)
-    end
-
-    it 'maps Mongoid column types to RA types' do
-      properties = %w(_id array_field big_decimal_field boolean_field bson_object_id_field bson_binary_field date_field datetime_field time_with_zone_field default_field float_field hash_field integer_field name object_field range_field short_text string_field subject symbol_field text_field time_field title)
-      expect(@abstract_model.properties.select { |p| properties.include? p[:name].to_s }).to match_array [
-        {:name => :_id,
-         :pretty_name => 'Id',
-         :nullable? => true,
-         :serial? => true,
-         :type => :bson_object_id,
-         :length => nil},
-        {:name => :array_field,
-         :pretty_name => 'Array field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :serialized,
-         :length => nil},
-        {:name => :big_decimal_field,
-         :pretty_name => 'Big decimal field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :decimal,
-         :length => nil},
-        {:name => :boolean_field,
-         :pretty_name => 'Boolean field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :boolean,
-         :length => nil},
-        {:name => :bson_object_id_field,
-         :pretty_name => 'Bson object id field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :bson_object_id,
-         :length => nil},
-        {:name => :date_field,
-         :pretty_name => 'Date field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :date,
-         :length => nil},
-        {:name => :datetime_field,
-         :pretty_name => 'Datetime field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :datetime,
-         :length => nil},
-        {:name => :time_with_zone_field,
-         :pretty_name => 'Time with zone field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :datetime,
-         :length => nil},
-        {:name => :default_field,
-         :pretty_name => 'Default field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :string,
-         :length => 255},
-        {:name => :float_field,
-         :pretty_name => 'Float field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :float,
-         :length => nil},
-        {:name => :hash_field,
-         :pretty_name => 'Hash field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :serialized,
-         :length => nil},
-        {:name => :integer_field,
-         :pretty_name => 'Integer field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :integer,
-         :length => nil},
-        {:name => :name,
-         :pretty_name => 'Name',
-         :nullable? => true,
-         :serial? => false,
-         :type => :string,
-         :length => 255},
-        {:name => :object_field,
-         :pretty_name => 'Object field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :string,
-         :length => 255},
-        {:name => :short_text,
-         :pretty_name => 'Short text',
-         :nullable? => true,
-         :serial? => false,
-         :type => :string,
-         :length => 255},
-        {:name => :string_field,
-         :pretty_name => 'String field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :text,
-         :length => nil},
-        {:name => :subject,
-         :pretty_name => 'Subject',
-         :nullable? => true,
-         :serial? => false,
-         :type => :string,
-         :length => 255},
-        {:name => :symbol_field,
-         :pretty_name => 'Symbol field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :string,
-         :length => 255},
-        {:name => :text_field,
-         :pretty_name => 'Text field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :text,
-         :length => nil},
-        {:name => :time_field,
-         :pretty_name => 'Time field',
-         :nullable? => true,
-         :serial? => false,
-         :type => :datetime,
-         :length => nil},
-        {:name => :title,
-         :pretty_name => 'Title',
-         :nullable? => true,
-         :serial? => false,
-         :type => :string,
-         :length => 255}
-      ]
-    end
-
-    it 'detects validation length properly' do
-      class LengthValiated
-        include Mongoid::Document
-        field :text, type: String
-        validates :text, length: {maximum: 50}
-      end
-      expect(RailsAdmin::AbstractModel.new('LengthValiated').send(:length_validation_lookup, :text)).to eq(50)
-    end
-
-    it 'does not cause problem with custom validators' do
-      class MyCustomValidator < ActiveModel::Validator
-        def validate(r); end
-      end
-      class CustomValiated
-        include Mongoid::Document
-        field :text, type: String
-        validates_with MyCustomValidator
-      end
-      expect(lambda { RailsAdmin::AbstractModel.new('CustomValiated').send(:length_validation_lookup, :text) }).not_to raise_error
+    it 'returns Property class' do
+      expect(RailsAdmin::AbstractModel.new(Player).properties.first).
+        to be_a_kind_of RailsAdmin::Adapters::Mongoid::Property
     end
   end
 
-  describe 'data access method' do
+  describe 'data access methods' do
     before do
       @players = FactoryGirl.create_list(:player, 3)
       @abstract_model = RailsAdmin::AbstractModel.new('Player')
@@ -686,10 +261,10 @@ describe 'RailsAdmin::Adapters::Mongoid', mongoid: true do
     end
 
     it 'supports boolean type query' do
-      %w(false f 0).each do |value|
+      %w[false f 0].each do |value|
         expect(@abstract_model.send(:build_statement, :field, :boolean, value, nil)).to eq(field: false)
       end
-      %w(true t 1).each do |value|
+      %w[true t 1].each do |value|
         expect(@abstract_model.send(:build_statement, :field, :boolean, value, nil)).to eq(field: true)
       end
       expect(@abstract_model.send(:build_statement, :field, :boolean, 'word', nil)).to be_nil
@@ -706,7 +281,7 @@ describe 'RailsAdmin::Adapters::Mongoid', mongoid: true do
       expect(@abstract_model.send(:build_statement, :field, :integer, ['', '3', ''], 'between')).to eq(field: {'$gte' => 3})
       expect(@abstract_model.send(:build_statement, :field, :integer, ['', '', '5'], 'between')).to eq(field: {'$lte' => 5})
       expect(@abstract_model.send(:build_statement, :field, :integer, [''  , '10', '20'], 'between')).to eq(field: {'$gte' => 10, '$lte' => 20})
-      expect(@abstract_model.send(:build_statement, :field, :integer, %w(15 10 20), 'between')).to eq(field: {'$gte' => 10, '$lte' => 20})
+      expect(@abstract_model.send(:build_statement, :field, :integer, %w[15 10 20], 'between')).to eq(field: {'$gte' => 10, '$lte' => 20})
       expect(@abstract_model.send(:build_statement, :field, :integer, ['', 'word1', ''], 'between')).to be_nil
       expect(@abstract_model.send(:build_statement, :field, :integer, ['', ''     , 'word2'], 'between')).to be_nil
       expect(@abstract_model.send(:build_statement, :field, :integer, ['', 'word3', 'word4'], 'between')).to be_nil