added mongoid search specs
This commit is contained in:
parent
b3234d20f3
commit
1799766abd
|
@ -0,0 +1,447 @@
|
|||
require 'mongoid_spec_helper'
|
||||
|
||||
module Ransack
|
||||
describe Search do
|
||||
describe '#initialize' do
|
||||
it "removes empty conditions before building" do
|
||||
expect_any_instance_of(Search).to receive(:build).with({})
|
||||
Search.new(Person, :name_eq => '')
|
||||
end
|
||||
|
||||
it "keeps conditions with a false value before building" do
|
||||
expect_any_instance_of(Search).to receive(:build).with({"name_eq" => false})
|
||||
Search.new(Person, :name_eq => false)
|
||||
end
|
||||
|
||||
it "keeps conditions with a value before building" do
|
||||
expect_any_instance_of(Search).to receive(:build).with({"name_eq" => 'foobar'})
|
||||
Search.new(Person, :name_eq => 'foobar')
|
||||
end
|
||||
|
||||
it "removes empty suffixed conditions before building" do
|
||||
expect_any_instance_of(Search).to receive(:build).with({})
|
||||
Search.new(Person, :name_eq_any => [''])
|
||||
end
|
||||
|
||||
it "keeps suffixed conditions with a false value before building" do
|
||||
expect_any_instance_of(Search).to receive(:build).with({"name_eq_any" => [false]})
|
||||
Search.new(Person, :name_eq_any => [false])
|
||||
end
|
||||
|
||||
it "keeps suffixed conditions with a value before building" do
|
||||
expect_any_instance_of(Search).to receive(:build).with({"name_eq_any" => ['foobar']})
|
||||
Search.new(Person, :name_eq_any => ['foobar'])
|
||||
end
|
||||
|
||||
it 'does not raise exception for string :params argument' do
|
||||
expect { Search.new(Person, '') }.not_to raise_error
|
||||
end
|
||||
end
|
||||
|
||||
describe '#build' do
|
||||
it 'creates conditions for top-level attributes' do
|
||||
search = Search.new(Person, :name_eq => 'Ernie')
|
||||
condition = search.base[:name_eq]
|
||||
expect(condition).to be_a Nodes::Condition
|
||||
expect(condition.predicate.name).to eq 'eq'
|
||||
expect(condition.attributes.first.name).to eq 'name'
|
||||
expect(condition.value).to eq 'Ernie'
|
||||
end
|
||||
|
||||
context 'joins' do
|
||||
before { pending 'not implemented for mongoid' }
|
||||
|
||||
it 'creates conditions for association attributes' do
|
||||
search = Search.new(Person, :children_name_eq => 'Ernie')
|
||||
condition = search.base[:children_name_eq]
|
||||
binding.pry
|
||||
expect(condition).to be_a Nodes::Condition
|
||||
expect(condition.predicate.name).to eq 'eq'
|
||||
expect(condition.attributes.first.name).to eq 'children_name'
|
||||
expect(condition.value).to eq 'Ernie'
|
||||
end
|
||||
|
||||
it 'creates conditions for polymorphic belongs_to association attributes' do
|
||||
search = Search.new(Note, :notable_of_Person_type_name_eq => 'Ernie')
|
||||
condition = search.base[:notable_of_Person_type_name_eq]
|
||||
expect(condition).to be_a Nodes::Condition
|
||||
expect(condition.predicate.name).to eq 'eq'
|
||||
expect(condition.attributes.first.name).to eq 'notable_of_Person_type_name'
|
||||
expect(condition.value).to eq 'Ernie'
|
||||
end
|
||||
|
||||
it 'creates conditions for multiple polymorphic belongs_to association attributes' do
|
||||
search = Search.new(Note,
|
||||
:notable_of_Person_type_name_or_notable_of_Article_type_title_eq => 'Ernie')
|
||||
condition = search.
|
||||
base[:notable_of_Person_type_name_or_notable_of_Article_type_title_eq]
|
||||
expect(condition).to be_a Nodes::Condition
|
||||
expect(condition.predicate.name).to eq 'eq'
|
||||
expect(condition.attributes.first.name).to eq 'notable_of_Person_type_name'
|
||||
expect(condition.attributes.last.name).to eq 'notable_of_Article_type_title'
|
||||
expect(condition.value).to eq 'Ernie'
|
||||
end
|
||||
before { skip }
|
||||
it 'accepts arrays of groupings with joins' do
|
||||
search = Search.new(Person,
|
||||
g: [
|
||||
{ :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie' },
|
||||
{ :m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert' },
|
||||
]
|
||||
)
|
||||
ors = search.groupings
|
||||
expect(ors.size).to eq(2)
|
||||
or1, or2 = ors
|
||||
expect(or1).to be_a Nodes::Grouping
|
||||
expect(or1.combinator).to eq 'or'
|
||||
expect(or2).to be_a Nodes::Grouping
|
||||
expect(or2.combinator).to eq 'or'
|
||||
end
|
||||
|
||||
it 'accepts "attributes" hashes for groupings' do
|
||||
search = Search.new(Person,
|
||||
g: {
|
||||
'0' => { m: 'or', name_eq: 'Ernie', children_name_eq: 'Ernie' },
|
||||
'1' => { m: 'or', name_eq: 'Bert', children_name_eq: 'Bert' },
|
||||
}
|
||||
)
|
||||
ors = search.groupings
|
||||
expect(ors.size).to eq(2)
|
||||
or1, or2 = ors
|
||||
expect(or1).to be_a Nodes::Grouping
|
||||
expect(or1.combinator).to eq 'or'
|
||||
expect(or2).to be_a Nodes::Grouping
|
||||
expect(or2.combinator).to eq 'or'
|
||||
end
|
||||
|
||||
it 'accepts "attributes" hashes for conditions' do
|
||||
search = Search.new(Person,
|
||||
:c => {
|
||||
'0' => { :a => ['name'], :p => 'eq', :v => ['Ernie'] },
|
||||
'1' => { :a => ['children_name', 'parent_name'],
|
||||
:p => 'eq', :v => ['Ernie'], :m => 'or' }
|
||||
}
|
||||
)
|
||||
conditions = search.base.conditions
|
||||
expect(conditions.size).to eq(2)
|
||||
expect(conditions.map { |c| c.class })
|
||||
.to eq [Nodes::Condition, Nodes::Condition]
|
||||
end
|
||||
|
||||
before { skip }
|
||||
it 'does not evaluate the query on #inspect' do
|
||||
search = Search.new(Person, :children_id_in => [1, 2, 3])
|
||||
expect(search.inspect).not_to match /ActiveRecord/
|
||||
end
|
||||
end
|
||||
|
||||
it 'discards empty conditions' do
|
||||
search = Search.new(Person, :children_name_eq => '')
|
||||
condition = search.base[:children_name_eq]
|
||||
expect(condition).to be_nil
|
||||
end
|
||||
|
||||
it 'accepts arrays of groupings' do
|
||||
search = Search.new(Person,
|
||||
g: [
|
||||
{ :m => 'or', :name_eq => 'Ernie', :email_eq => 'ernie@example.org' },
|
||||
{ :m => 'or', :name_eq => 'Bert', :email_eq => 'bert@example.org' },
|
||||
]
|
||||
)
|
||||
ors = search.groupings
|
||||
expect(ors.size).to eq(2)
|
||||
or1, or2 = ors
|
||||
expect(or1).to be_a Nodes::Grouping
|
||||
expect(or1.combinator).to eq 'or'
|
||||
expect(or2).to be_a Nodes::Grouping
|
||||
expect(or2.combinator).to eq 'or'
|
||||
end
|
||||
|
||||
it 'creates conditions for custom predicates that take arrays' do
|
||||
Ransack.configure do |config|
|
||||
config.add_predicate 'ary_pred', :wants_array => true
|
||||
end
|
||||
|
||||
search = Search.new(Person, :name_ary_pred => ['Ernie', 'Bert'])
|
||||
condition = search.base[:name_ary_pred]
|
||||
expect(condition).to be_a Nodes::Condition
|
||||
expect(condition.predicate.name).to eq 'ary_pred'
|
||||
expect(condition.attributes.first.name).to eq 'name'
|
||||
expect(condition.value).to eq ['Ernie', 'Bert']
|
||||
end
|
||||
|
||||
context 'with an invalid condition' do
|
||||
subject { Search.new(Person, :unknown_attr_eq => 'Ernie') }
|
||||
|
||||
context "when ignore_unknown_conditions is false" do
|
||||
before do
|
||||
Ransack.configure { |config| config.ignore_unknown_conditions = false }
|
||||
end
|
||||
|
||||
specify { expect { subject }.to raise_error ArgumentError }
|
||||
end
|
||||
|
||||
context "when ignore_unknown_conditions is true" do
|
||||
before do
|
||||
Ransack.configure { |config| config.ignore_unknown_conditions = true }
|
||||
end
|
||||
|
||||
specify { expect { subject }.not_to raise_error }
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
describe '#result' do
|
||||
let(:people_name_field) {
|
||||
"#{quote_table_name("people")}.#{quote_column_name("name")}"
|
||||
}
|
||||
# let(:children_people_name_field) {
|
||||
# "#{quote_table_name("children_people")}.#{quote_column_name("name")}"
|
||||
# }
|
||||
|
||||
it 'evaluates arrays of groupings' do
|
||||
search = Search.new(Person,
|
||||
:g => [
|
||||
{ :m => 'or', :name_eq => 'Ernie', :email_eq => 'ernie@example.org' },
|
||||
{ :m => 'or', :name_eq => 'Bert', :email_eq => 'bert@example.org' }
|
||||
]
|
||||
)
|
||||
expect(search.result).to be_an Mongoid::Criteria
|
||||
selector = search.result.selector
|
||||
expect(selector.keys).to eq ['$and']
|
||||
first, second = selector.values.first
|
||||
expect(first).to eq({ '$or' => [ { 'name' => 'Ernie' }, { 'email' => 'ernie@example.org' } ] })
|
||||
expect(second).to eq({ '$or' => [ { 'name' => 'Bert' }, { 'email' => 'bert@example.org' } ] })
|
||||
end
|
||||
|
||||
context 'with joins' do
|
||||
before { pending 'not implemented for mongoid' }
|
||||
|
||||
it 'evaluates conditions contextually' do
|
||||
search = Search.new(Person, :children_name_eq => 'Ernie')
|
||||
expect(search.result).to be_an ActiveRecord::Relation
|
||||
where = search.result.where_values.first
|
||||
expect(where.to_sql).to match /#{children_people_name_field} = 'Ernie'/
|
||||
end
|
||||
|
||||
it 'evaluates compound conditions contextually' do
|
||||
search = Search.new(Person, :children_name_or_name_eq => 'Ernie')
|
||||
expect(search.result).to be_an ActiveRecord::Relation
|
||||
where = search.result.where_values.first
|
||||
expect(where.to_sql).to match /#{children_people_name_field
|
||||
} = 'Ernie' OR #{people_name_field} = 'Ernie'/
|
||||
end
|
||||
|
||||
it 'evaluates polymorphic belongs_to association conditions contextually' do
|
||||
search = Search.new(Note, :notable_of_Person_type_name_eq => 'Ernie')
|
||||
expect(search.result).to be_an ActiveRecord::Relation
|
||||
where = search.result.where_values.first
|
||||
expect(where.to_sql).to match /#{people_name_field} = 'Ernie'/
|
||||
end
|
||||
|
||||
it 'evaluates nested conditions' do
|
||||
search = Search.new(Person, :children_name_eq => 'Ernie',
|
||||
:g => [
|
||||
{ :m => 'or',
|
||||
:name_eq => 'Ernie',
|
||||
:children_children_name_eq => 'Ernie'
|
||||
}
|
||||
]
|
||||
)
|
||||
expect(search.result).to be_an ActiveRecord::Relation
|
||||
where = search.result.where_values.first
|
||||
expect(where.to_sql).to match /#{children_people_name_field} = 'Ernie'/
|
||||
expect(where.to_sql).to match /#{people_name_field} = 'Ernie'/
|
||||
expect(where.to_sql).to match /#{quote_table_name("children_people_2")
|
||||
}.#{quote_column_name("name")} = 'Ernie'/
|
||||
end
|
||||
|
||||
it 'evaluates arrays of groupings' do
|
||||
search = Search.new(Person,
|
||||
:g => [
|
||||
{ :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie' },
|
||||
{ :m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert' }
|
||||
]
|
||||
)
|
||||
expect(search.result).to be_an ActiveRecord::Relation
|
||||
where = search.result.where_values.first
|
||||
sql = where.to_sql
|
||||
first, second = sql.split(/ AND /)
|
||||
expect(first).to match /#{people_name_field} = 'Ernie'/
|
||||
expect(first).to match /#{children_people_name_field} = 'Ernie'/
|
||||
expect(second).to match /#{people_name_field} = 'Bert'/
|
||||
expect(second).to match /#{children_people_name_field} = 'Bert'/
|
||||
end
|
||||
|
||||
it 'returns distinct records when passed :distinct => true' do
|
||||
search = Search.new(
|
||||
Person, :g => [
|
||||
{ :m => 'or',
|
||||
:comments_body_cont => 'e',
|
||||
:articles_comments_body_cont => 'e'
|
||||
}
|
||||
]
|
||||
)
|
||||
if ActiveRecord::VERSION::MAJOR == 3
|
||||
all_or_load, uniq_or_distinct = :all, :uniq
|
||||
else
|
||||
all_or_load, uniq_or_distinct = :load, :distinct
|
||||
end
|
||||
expect(search.result.send(all_or_load).size).
|
||||
to eq(9000)
|
||||
expect(search.result(:distinct => true).size).
|
||||
to eq(10)
|
||||
expect(search.result.send(all_or_load).send(uniq_or_distinct)).
|
||||
to eq search.result(:distinct => true).send(all_or_load)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
describe '#sorts=' do
|
||||
before do
|
||||
@s = Search.new(Person)
|
||||
end
|
||||
|
||||
it 'creates sorts based on a single attribute/direction' do
|
||||
@s.sorts = 'id desc'
|
||||
expect(@s.sorts.size).to eq(1)
|
||||
sort = @s.sorts.first
|
||||
expect(sort).to be_a Nodes::Sort
|
||||
expect(sort.name).to eq 'id'
|
||||
expect(sort.dir).to eq 'desc'
|
||||
expect(@s.result.options).to eq({ :sort => { '_id' => -1 } })
|
||||
end
|
||||
|
||||
it 'creates sorts based on a single attribute and uppercase direction' do
|
||||
@s.sorts = 'id DESC'
|
||||
expect(@s.sorts.size).to eq(1)
|
||||
sort = @s.sorts.first
|
||||
expect(sort).to be_a Nodes::Sort
|
||||
expect(sort.name).to eq 'id'
|
||||
expect(sort.dir).to eq 'desc'
|
||||
expect(@s.result.options).to eq({ :sort => { '_id' => -1 } })
|
||||
end
|
||||
|
||||
it 'creates sorts based on a single attribute and without direction' do
|
||||
@s.sorts = 'id'
|
||||
expect(@s.sorts.size).to eq(1)
|
||||
sort = @s.sorts.first
|
||||
expect(sort).to be_a Nodes::Sort
|
||||
expect(sort.name).to eq 'id'
|
||||
expect(sort.dir).to eq 'asc'
|
||||
expect(@s.result.options).to eq({ :sort => { '_id' => 1 } })
|
||||
end
|
||||
|
||||
it 'creates sorts based on multiple attributes/directions in array format' do
|
||||
@s.sorts = ['id desc', { :name => 'name', :dir => 'asc' }]
|
||||
expect(@s.sorts.size).to eq(2)
|
||||
sort1, sort2 = @s.sorts
|
||||
expect(sort1).to be_a Nodes::Sort
|
||||
expect(sort1.name).to eq 'id'
|
||||
expect(sort1.dir).to eq 'desc'
|
||||
expect(sort2).to be_a Nodes::Sort
|
||||
expect(sort2.name).to eq 'name'
|
||||
expect(sort2.dir).to eq 'asc'
|
||||
expect(@s.result.options).to eq({ :sort=>{"_id"=>-1, "name"=>1} })
|
||||
end
|
||||
|
||||
it 'creates sorts based on multiple attributes and uppercase directions in array format' do
|
||||
@s.sorts = ['id DESC', { :name => 'name', :dir => 'ASC' }]
|
||||
expect(@s.sorts.size).to eq(2)
|
||||
sort1, sort2 = @s.sorts
|
||||
expect(sort1).to be_a Nodes::Sort
|
||||
expect(sort1.name).to eq 'id'
|
||||
expect(sort1.dir).to eq 'desc'
|
||||
expect(sort2).to be_a Nodes::Sort
|
||||
expect(sort2.name).to eq 'name'
|
||||
expect(sort2.dir).to eq 'asc'
|
||||
expect(@s.result.options).to eq({ :sort=>{"_id"=>-1, "name"=>1} })
|
||||
end
|
||||
|
||||
it 'creates sorts based on multiple attributes and different directions in array format' do
|
||||
@s.sorts = ['id DESC', { name: 'name', dir: nil }]
|
||||
expect(@s.sorts.size).to eq(2)
|
||||
sort1, sort2 = @s.sorts
|
||||
expect(sort1).to be_a Nodes::Sort
|
||||
expect(sort1.name).to eq 'id'
|
||||
expect(sort1.dir).to eq 'desc'
|
||||
expect(sort2).to be_a Nodes::Sort
|
||||
expect(sort2.name).to eq 'name'
|
||||
expect(sort2.dir).to eq 'asc'
|
||||
expect(@s.result.options).to eq({ :sort=>{"_id"=>-1, "name"=>1} })
|
||||
end
|
||||
|
||||
it 'creates sorts based on multiple attributes/directions in hash format' do
|
||||
@s.sorts = {
|
||||
'0' => { :name => 'id', :dir => 'desc' },
|
||||
'1' => { :name => 'name', :dir => 'asc' }
|
||||
}
|
||||
expect(@s.sorts.size).to eq(2)
|
||||
expect(@s.sorts).to be_all { |s| Nodes::Sort === s }
|
||||
id_sort = @s.sorts.detect { |s| s.name == 'id' }
|
||||
name_sort = @s.sorts.detect { |s| s.name == 'name' }
|
||||
expect(id_sort.dir).to eq 'desc'
|
||||
expect(name_sort.dir).to eq 'asc'
|
||||
expect(@s.result.options).to eq({ :sort=>{"_id"=>-1, "name"=>1} })
|
||||
end
|
||||
|
||||
it 'creates sorts based on multiple attributes and uppercase directions in hash format' do
|
||||
@s.sorts = {
|
||||
'0' => { :name => 'id', :dir => 'DESC' },
|
||||
'1' => { :name => 'name', :dir => 'ASC' }
|
||||
}
|
||||
expect(@s.sorts.size).to eq(2)
|
||||
expect(@s.sorts).to be_all { |s| Nodes::Sort === s }
|
||||
id_sort = @s.sorts.detect { |s| s.name == 'id' }
|
||||
name_sort = @s.sorts.detect { |s| s.name == 'name' }
|
||||
expect(id_sort.dir).to eq 'desc'
|
||||
expect(name_sort.dir).to eq 'asc'
|
||||
expect(@s.result.options).to eq({ :sort=>{"_id"=>-1, "name"=>1} })
|
||||
end
|
||||
|
||||
it 'creates sorts based on multiple attributes and different directions in hash format' do
|
||||
@s.sorts = {
|
||||
'0' => { :name => 'id', :dir => 'DESC' },
|
||||
'1' => { :name => 'name', :dir => nil }
|
||||
}
|
||||
expect(@s.sorts.size).to eq(2)
|
||||
expect(@s.sorts).to be_all { |s| Nodes::Sort === s }
|
||||
id_sort = @s.sorts.detect { |s| s.name == 'id' }
|
||||
name_sort = @s.sorts.detect { |s| s.name == 'name' }
|
||||
expect(id_sort.dir).to eq 'desc'
|
||||
expect(name_sort.dir).to eq 'asc'
|
||||
expect(@s.result.options).to eq({ :sort=>{"_id"=>-1, "name"=>1} })
|
||||
end
|
||||
|
||||
it 'overrides existing sort' do
|
||||
@s.sorts = 'id asc'
|
||||
expect(@s.result.first.id.to_s).to eq Person.min(:id).to_s
|
||||
end
|
||||
end
|
||||
|
||||
describe '#method_missing' do
|
||||
before do
|
||||
@s = Search.new(Person)
|
||||
end
|
||||
|
||||
it 'raises NoMethodError when sent an invalid attribute' do
|
||||
expect { @s.blah }.to raise_error NoMethodError
|
||||
end
|
||||
|
||||
it 'sets condition attributes when sent valid attributes' do
|
||||
@s.name_eq = 'Ernie'
|
||||
expect(@s.name_eq).to eq 'Ernie'
|
||||
end
|
||||
|
||||
context 'with joins' do
|
||||
before { pending 'not implemented for mongoid' }
|
||||
it 'allows chaining to access nested conditions' do
|
||||
@s.groupings = [
|
||||
{ :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie' }
|
||||
]
|
||||
expect(@s.groupings.first.children_name_eq).to eq 'Ernie'
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
|
@ -43,33 +43,33 @@ class Person
|
|||
|
||||
def self.ransackable_attributes(auth_object = nil)
|
||||
if auth_object == :admin
|
||||
column_names + _ransackers.keys - ['only_sort']
|
||||
super - ['only_sort']
|
||||
else
|
||||
column_names + _ransackers.keys - ['only_sort', 'only_admin']
|
||||
super - ['only_sort', 'only_admin']
|
||||
end
|
||||
end
|
||||
|
||||
def self.ransortable_attributes(auth_object = nil)
|
||||
if auth_object == :admin
|
||||
column_names + _ransackers.keys - ['only_search']
|
||||
super - ['only_search']
|
||||
else
|
||||
column_names + _ransackers.keys - ['only_search', 'only_admin']
|
||||
super - ['only_search', 'only_admin']
|
||||
end
|
||||
end
|
||||
|
||||
def self.ransackable_attributes(auth_object = nil)
|
||||
if auth_object == :admin
|
||||
column_names + _ransackers.keys - ['only_sort']
|
||||
super - ['only_sort']
|
||||
else
|
||||
column_names + _ransackers.keys - ['only_sort', 'only_admin']
|
||||
super - ['only_sort', 'only_admin']
|
||||
end
|
||||
end
|
||||
|
||||
def self.ransortable_attributes(auth_object = nil)
|
||||
if auth_object == :admin
|
||||
column_names + _ransackers.keys - ['only_search']
|
||||
super - ['only_search']
|
||||
else
|
||||
column_names + _ransackers.keys - ['only_search', 'only_admin']
|
||||
super - ['only_search', 'only_admin']
|
||||
end
|
||||
end
|
||||
end
|
||||
|
@ -77,7 +77,6 @@ end
|
|||
class Article
|
||||
include Mongoid::Document
|
||||
|
||||
field :person_id, type: Integer
|
||||
field :title, type: String
|
||||
field :body, type: String
|
||||
|
||||
|
@ -96,8 +95,6 @@ end
|
|||
class Comment
|
||||
include Mongoid::Document
|
||||
|
||||
field :article_id, type: Integer
|
||||
field :person_id, type: Integer
|
||||
field :body, type: String
|
||||
|
||||
|
||||
|
@ -116,8 +113,6 @@ end
|
|||
class Note
|
||||
include Mongoid::Document
|
||||
|
||||
field :notable_id, type: Integer
|
||||
field :notable_type, type: String
|
||||
field :note, type: String
|
||||
|
||||
belongs_to :notable, :polymorphic => true
|
||||
|
|
Loading…
Reference in New Issue