ransack 1.5.1 → 1.6.0

data/spec/mongoid/adapters/mongoid/context_spec.rb

@@ -0,0 +1,56 @@
+require 'mongoid_spec_helper'
+
+module Ransack
+  module Adapters
+    module Mongoid
+      describe Context do
+        subject { Context.new(Person) }
+
+        describe '#relation_for' do
+          before { pending "not implemented for mongoid" }
+          it 'returns relation for given object' do
+            expect(subject.object).to be_an ::ActiveRecord::Relation
+          end
+        end
+
+        describe '#evaluate' do
+          it 'evaluates search objects' do
+            search = Search.new(Person, :name_eq => 'Joe Blow')
+            result = subject.evaluate(search)
+
+            expect(result).to be_an ::Mongoid::Criteria
+            expect(result.selector).to eq({ 'name' => 'Joe Blow' })
+          end
+
+          it 'SELECTs DISTINCT when distinct: true' do
+            pending "distinct doesn't work"
+
+            search = Search.new(Person, :name_eq => 'Joe Blow')
+            result = subject.evaluate(search, :distinct => true)
+
+            expect(result).to be_an ::ActiveRecord::Relation
+            expect(result.to_sql).to match /SELECT DISTINCT/
+          end
+        end
+
+        it 'contextualizes strings to attributes' do
+          attribute = subject.contextualize 'name'
+          expect(attribute).to be_a ::Ransack::Adapters::Mongoid::Attributes::Attribute
+          expect(attribute.name.to_s).to eq 'name'
+          # expect(attribute.relation.table_alias).to eq 'parents_people'
+        end
+
+        it 'builds new associations if not yet built' do
+          pending "not implemented for mongoid"
+
+          attribute = subject.contextualize 'children_articles_title'
+          expect(attribute).to be_a Arel::Attributes::Attribute
+          expect(attribute.name.to_s).to eq 'title'
+          expect(attribute.relation.name).to eq 'articles'
+          expect(attribute.relation.table_alias).to be_nil
+        end
+
+      end
+    end
+  end
+end

data/spec/mongoid/configuration_spec.rb

@@ -0,0 +1,66 @@
+require 'mongoid_spec_helper'
+
+module Ransack
+  describe Configuration do
+    it 'yields Ransack on configure' do
+      Ransack.configure { |config| expect(config).to eq Ransack }
+    end
+
+    it 'adds predicates' do
+      Ransack.configure do |config|
+        config.add_predicate :test_predicate
+      end
+
+      expect(Ransack.predicates).to have_key 'test_predicate'
+      expect(Ransack.predicates).to have_key 'test_predicate_any'
+      expect(Ransack.predicates).to have_key 'test_predicate_all'
+    end
+
+    it 'avoids creating compound predicates if compounds: false' do
+      Ransack.configure do |config|
+        config.add_predicate(
+          :test_predicate_without_compound,
+          :compounds => false
+          )
+      end
+      expect(Ransack.predicates)
+      .to have_key 'test_predicate_without_compound'
+      expect(Ransack.predicates)
+      .not_to have_key 'test_predicate_without_compound_any'
+      expect(Ransack.predicates)
+      .not_to have_key 'test_predicate_without_compound_all'
+    end
+
+    it 'should have default value for search key' do
+      expect(Ransack.options[:search_key]).to eq :q
+    end
+
+    it 'changes default search key parameter' do
+      # store original state so we can restore it later
+      before = Ransack.options.clone
+
+      Ransack.configure do |config|
+        config.search_key = :query
+      end
+
+      expect(Ransack.options[:search_key]).to eq :query
+
+      # restore original state so we don't break other tests
+      Ransack.options = before
+    end
+
+    it 'adds predicates that take arrays, overriding compounds' do
+      Ransack.configure do |config|
+        config.add_predicate(
+          :test_array_predicate,
+          :wants_array => true,
+          :compounds => true
+          )
+      end
+
+      expect(Ransack.predicates['test_array_predicate'].wants_array).to eq true
+      expect(Ransack.predicates).not_to have_key 'test_array_predicate_any'
+      expect(Ransack.predicates).not_to have_key 'test_array_predicate_all'
+    end
+  end
+end

data/spec/mongoid/dependencies_spec.rb

@@ -0,0 +1,8 @@
+unless ::ActiveSupport::VERSION::STRING >= '4'
+  describe 'Ransack' do
+    it 'can be required without errors' do
+      output = `bundle exec ruby -e "require 'ransack'" 2>&1`
+      expect(output).to be_empty
+    end
+  end
+end

data/spec/mongoid/helpers/ransack_helper.rb

@@ -0,0 +1,11 @@
+module RansackHelper
+  def quote_table_name(table)
+    # ActiveRecord::Base.connection.quote_table_name(table)
+    table
+  end
+
+  def quote_column_name(column)
+    # ActiveRecord::Base.connection.quote_column_name(column)
+    column
+  end
+end

data/spec/mongoid/nodes/condition_spec.rb

@@ -0,0 +1,34 @@
+require 'mongoid_spec_helper'
+
+module Ransack
+  module Nodes
+    describe Condition do
+
+      context 'with multiple values and an _any predicate' do
+        subject { Condition.extract(Context.for(Person), 'name_eq_any', Person.first(2).map(&:name)) }
+
+        specify { expect(subject.values.size).to eq(2) }
+      end
+
+      context 'with an invalid predicate' do
+        subject { Condition.extract(Context.for(Person), 'name_invalid', Person.first.name) }
+
+        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 { subject.should be_nil }
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/nodes/grouping_spec.rb

@@ -0,0 +1,13 @@
+require 'mongoid_spec_helper'
+
+module Ransack
+  module Nodes
+    describe Grouping do
+      before do
+        @g = 1
+      end
+
+
+    end
+  end
+end

data/spec/mongoid/predicate_spec.rb

@@ -0,0 +1,155 @@
+require 'mongoid_spec_helper'
+
+module Ransack
+  describe Predicate do
+
+    before do
+      @s = Search.new(Person)
+    end
+
+    shared_examples 'wildcard escaping' do |method, value|
+      it 'automatically converts integers to strings' do
+        subject.parent_id_cont = 1
+        expect { subject.result }.to_not raise_error
+      end
+
+      it "escapes '%', '.' and '\\\\' in value" do
+        subject.send(:"#{method}=", '%._\\')
+        expect(subject.result.selector).to eq(value)
+      end
+    end
+
+    describe 'eq' do
+      it 'generates an equality condition for boolean true' do
+        @s.awesome_eq = true
+        expect(@s.result.selector).to eq({ "awesome" => true })
+      end
+
+      it 'generates an equality condition for boolean false' do
+        @s.awesome_eq = false
+        expect(@s.result.selector).to eq({ "awesome" => false })
+      end
+
+      it 'does not generate a condition for nil' do
+        @s.awesome_eq = nil
+        expect(@s.result.selector).to eq({ })
+      end
+    end
+
+    describe 'cont' do
+      it_has_behavior 'wildcard escaping', :name_cont, { 'name' => /%\._\\/i } do
+        subject { @s }
+      end
+
+      it 'generates a regex query' do
+        @s.name_cont = 'ric'
+        expect(@s.result.selector).to eq({ 'name' => /ric/i })
+      end
+    end
+
+    describe 'not_cont' do
+      it_has_behavior 'wildcard escaping', :name_not_cont, { "$not" => { 'name' => /%\._\\/i } } do
+        subject { @s }
+      end
+
+      it 'generates a regex query' do
+        @s.name_not_cont = 'ric'
+        expect(@s.result.selector).to eq({ "$not" => { 'name' => /ric/i } })
+      end
+    end
+
+    describe 'null' do
+      it 'generates a value IS NULL query' do
+        @s.name_null = true
+        expect(@s.result.selector).to eq({ 'name' => nil })
+      end
+
+      it 'generates a value IS NOT NULL query when assigned false' do
+        @s.name_null = false
+        expect(@s.result.selector).to eq( { 'name' => { '$ne' => nil } })
+      end
+    end
+
+    describe 'not_null' do
+      it 'generates a value IS NOT NULL query' do
+        @s.name_not_null = true
+        expect(@s.result.selector).to eq({ 'name' => { '$ne' => nil } })
+      end
+
+      it 'generates a value IS NULL query when assigned false' do
+        @s.name_not_null = false
+        expect(@s.result.selector).to eq({ 'name' => nil })
+      end
+    end
+
+    describe 'present' do
+      it %q[generates a value IS NOT NULL AND value != '' query] do
+        @s.name_present = true
+        expect(@s.result.selector).to eq({ '$and' => [ { 'name' => { '$ne' => nil } }, { 'name' => { '$ne' => '' } } ] })
+      end
+
+      it %q[generates a value IS NULL OR value = '' query when assigned false] do
+        @s.name_present = false
+        expect(@s.result.selector).to eq({ '$or' => [ { 'name' => nil }, { 'name' => '' } ] })
+      end
+    end
+
+    describe 'blank' do
+      it %q[generates a value IS NULL OR value = '' query] do
+        @s.name_blank = true
+        expect(@s.result.selector).to eq({ '$or' => [ { 'name' => nil}, { 'name' => '' } ] })
+      end
+
+      it %q[generates a value IS NOT NULL AND value != '' query when assigned false] do
+        @s.name_blank = false
+        expect(@s.result.selector).to eq({ '$and' => [ { 'name' => { '$ne' => nil}}, { 'name' => { '$ne' => '' }} ] })
+      end
+    end
+
+    describe 'gt' do
+      it 'generates an greater than for time' do
+        time = Time.now
+        @s.created_at_gt = time
+        expect(@s.result.selector).to eq({ "created_at" => { '$gt' => time } })
+      end
+    end
+
+    describe 'lt' do
+      it 'generates an greater than for time' do
+        time = Time.now
+        @s.created_at_lt = time
+        expect(@s.result.selector).to eq({ "created_at" => { '$lt' => time } })
+      end
+    end
+
+    describe 'gteq' do
+      it 'generates an greater than for time' do
+        time = Time.now
+        @s.created_at_gteq = time
+        expect(@s.result.selector).to eq({ "created_at" => { '$gte' => time } })
+      end
+    end
+
+    describe 'lteq' do
+      it 'generates an greater than for time' do
+        time = Time.now
+        @s.created_at_lteq = time
+        expect(@s.result.selector).to eq({ "created_at" => { '$lte' => time } })
+      end
+    end
+
+    describe 'starts_with' do
+      it 'generates an starts_with' do
+        @s.name_start = 'ric'
+        expect(@s.result.selector).to eq({ "name" => /\Aric/i })
+      end
+    end
+
+    describe 'ends_with' do
+      it 'generates an ends_with' do
+        @s.name_end = 'ric'
+        expect(@s.result.selector).to eq({ "name" => /ric\Z/i })
+      end
+    end
+  end
+end

data/spec/mongoid/search_spec.rb

@@ -0,0 +1,446 @@
+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]
+          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 { |c| c.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 { |c| c.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