ransack 1.6.6 → 2.4.0

data/spec/ransack/nodes/condition_spec.rb

@@ -4,6 +4,21 @@ module Ransack
   module Nodes
     describe Condition do
 
+      context 'with an alias' do
+        subject {
+          Condition.extract(
+            Context.for(Person), 'term_start', Person.first(2).map(&:name)
+          )
+        }
+
+        specify { expect(subject.combinator).to eq 'or' }
+        specify { expect(subject.predicate.name).to eq 'start' }
+
+        it 'converts the alias to the correct attributes' do
+          expect(subject.attributes.map(&:name)).to eq(['name', 'email'])
+        end
+      end
+
       context 'with multiple values and an _any predicate' do
         subject {
           Condition.extract(
@@ -14,6 +29,15 @@ module Ransack
         specify { expect(subject.values.size).to eq(2) }
       end
 
+      describe '#negative?' do
+        let(:context) { Context.for(Person) }
+        let(:eq)      { Condition.extract(context, 'name_eq', 'A') }
+        let(:not_eq)  { Condition.extract(context, 'name_not_eq', 'A') }
+
+        specify { expect(not_eq.negative?).to be true }
+        specify { expect(eq.negative?).to be false }
+      end
+
       context 'with an invalid predicate' do
         subject {
           Condition.extract(
@@ -34,7 +58,7 @@ module Ransack
             Ransack.configure { |c| c.ignore_unknown_conditions = true }
           end
 
-          specify { subject.should be_nil }
+          specify { expect(subject).to be_nil }
         end
       end
     end

data/spec/ransack/nodes/grouping_spec.rb

@@ -15,37 +15,93 @@ module Ransack
       describe '#attribute_method?' do
         context 'for attributes of the context' do
           it 'is true' do
-            expect(subject.attribute_method?('name')).to be_true
+            expect(subject.attribute_method?('name')).to be true
           end
 
           context "when the attribute contains '_and_'" do
             it 'is true' do
-              expect(subject.attribute_method?('terms_and_conditions')).to be_true
+              expect(subject.attribute_method?('terms_and_conditions')).to be true
             end
           end
 
           context "when the attribute contains '_or_'" do
             it 'is true' do
-              expect(subject.attribute_method?('true_or_false')).to be_true
+              expect(subject.attribute_method?('true_or_false')).to be true
             end
           end
 
           context "when the attribute ends with '_start'" do
             it 'is true' do
-              expect(subject.attribute_method?('life_start')).to be_true
+              expect(subject.attribute_method?('life_start')).to be true
             end
           end
 
           context "when the attribute ends with '_end'" do
             it 'is true' do
-              expect(subject.attribute_method?('stop_end')).to be_true
+              expect(subject.attribute_method?('stop_end')).to be true
             end
           end
         end
 
         context 'for unknown attributes' do
           it 'is false' do
-            expect(subject.attribute_method?('not_an_attribute')).to be_false
+            expect(subject.attribute_method?('not_an_attribute')).to be false
+          end
+        end
+      end
+
+      describe '#conditions=' do
+        context 'when conditions are identical' do
+          let(:conditions) do
+            {
+              '0' => {
+                'a' => { '0'=> { 'name' => 'name', 'ransacker_args' => '' } },
+                'p' => 'cont',
+                'v' => { '0' => { 'value' => 'John' } }
+              },
+              '1' => {
+                'a' => { '0' => { 'name' => 'name', 'ransacker_args' => '' } },
+                'p' => 'cont',
+                'v' => { '0' => { 'value' => 'John' } }
+              }
+            }
+          end
+          before { subject.conditions = conditions }
+
+          it 'expect duplicates to be removed' do
+            expect(subject.conditions.count).to eq 1
+          end
+        end
+
+        context 'when conditions differ only by ransacker_args' do
+          let(:conditions) do
+            {
+              '0' => {
+                'a' => {
+                  '0' => {
+                    'name' => 'with_arguments',
+                    'ransacker_args' => [1,2]
+                  }
+                },
+                'p' => 'eq',
+                'v' => { '0' => { 'value' => '10' } }
+              },
+              '1' => {
+                'a' => {
+                  '0' => {
+                    'name' => 'with_arguments',
+                    'ransacker_args' => [3,4]
+                  }
+                },
+                'p' => 'eq',
+                'v' => { '0' => { 'value' => '10' } }
+              }
+            }
+          end
+          before { subject.conditions = conditions }
+
+          it 'expect them to be parsed as different and not as duplicates' do
+            expect(subject.conditions.count).to eq 2
           end
         end
       end

data/spec/ransack/predicate_spec.rb

@@ -16,7 +16,7 @@ module Ransack
         expect { subject.result }.to_not raise_error
       end
 
-      it "escapes '%', '.' and '\\\\' in value" do
+      it "escapes '%', '.', '_' and '\\\\' in value" do
         subject.send(:"#{method}=", '%._\\')
         expect(subject.result.to_sql).to match(regexp)
       end
@@ -124,9 +124,9 @@ module Ransack
     describe 'cont' do
       it_has_behavior 'wildcard escaping', :name_cont,
         (if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
-          /"people"."name" ILIKE '%\\%\\._\\\\%'/
+          /"people"."name" ILIKE '%\\%\\.\\_\\\\%'/
         elsif ActiveRecord::Base.connection.adapter_name == "Mysql2"
-          /`people`.`name` LIKE '%\\\\%\\\\._\\\\\\\\%'/
+          /`people`.`name` LIKE '%\\\\%.\\\\_\\\\\\\\%'/
         else
          /"people"."name" LIKE '%%._\\%'/
         end) do
@@ -143,9 +143,9 @@ module Ransack
     describe 'not_cont' do
       it_has_behavior 'wildcard escaping', :name_not_cont,
         (if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
-          /"people"."name" NOT ILIKE '%\\%\\._\\\\%'/
+          /"people"."name" NOT ILIKE '%\\%\\.\\_\\\\%'/
         elsif ActiveRecord::Base.connection.adapter_name == "Mysql2"
-          /`people`.`name` NOT LIKE '%\\\\%\\\\._\\\\\\\\%'/
+          /`people`.`name` NOT LIKE '%\\\\%.\\\\_\\\\\\\\%'/
         else
          /"people"."name" NOT LIKE '%%._\\%'/
         end) do
@@ -159,6 +159,44 @@ module Ransack
       end
     end
 
+    describe 'i_cont' do
+      it_has_behavior 'wildcard escaping', :name_i_cont,
+        (if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+          /"people"."name" ILIKE '%\\%\\.\\_\\\\%'/
+        elsif ActiveRecord::Base.connection.adapter_name == "Mysql2"
+          /LOWER\(`people`.`name`\) LIKE '%\\\\%.\\\\_\\\\\\\\%'/
+        else
+         /LOWER\("people"."name"\) LIKE '%%._\\%'/
+        end) do
+        subject { @s }
+      end
+
+      it 'generates a LIKE query with LOWER(column) and value surrounded by %' do
+        @s.name_i_cont = 'Ric'
+        field = "#{quote_table_name("people")}.#{quote_column_name("name")}"
+        expect(@s.result.to_sql).to match /[LOWER\(]?#{field}\)? I?LIKE '%ric%'/
+      end
+    end
+
+    describe 'not_i_cont' do
+      it_has_behavior 'wildcard escaping', :name_not_i_cont,
+        (if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+          /"people"."name" NOT ILIKE '%\\%\\.\\_\\\\%'/
+        elsif ActiveRecord::Base.connection.adapter_name == "Mysql2"
+          /LOWER\(`people`.`name`\) NOT LIKE '%\\\\%.\\\\_\\\\\\\\%'/
+        else
+         /LOWER\("people"."name"\) NOT LIKE '%%._\\%'/
+        end) do
+        subject { @s }
+      end
+
+      it 'generates a NOT LIKE query with LOWER(column) and value surrounded by %' do
+        @s.name_not_i_cont = 'Ric'
+        field = "#{quote_table_name("people")}.#{quote_column_name("name")}"
+        expect(@s.result.to_sql).to match /[LOWER\(]?#{field}\)? NOT I?LIKE '%ric%'/
+      end
+    end
+
     describe 'start' do
       it 'generates a LIKE query with value followed by %' do
         @s.name_start = 'Er'
@@ -329,6 +367,28 @@ module Ransack
         field = "#{quote_table_name("people")}.#{quote_column_name("name")}"
         expect(@s.result.to_sql).to match /#{field} IS NULL/
       end
+
+      describe 'with association qeury' do
+        it 'generates a value IS NOT NULL query' do
+          @s.comments_id_not_null = true
+          sql = @s.result.to_sql
+          parent_field = "#{quote_table_name("people")}.#{quote_column_name("id")}"
+          expect(sql).to match /#{parent_field} IN/
+          field = "#{quote_table_name("comments")}.#{quote_column_name("id")}"
+          expect(sql).to match /#{field} IS NOT NULL/
+          expect(sql).not_to match /AND NOT/
+        end
+
+        it 'generates a value IS NULL query when assigned false' do
+          @s.comments_id_not_null = false
+          sql = @s.result.to_sql
+          parent_field = "#{quote_table_name("people")}.#{quote_column_name("id")}"
+          expect(sql).to match /#{parent_field} NOT IN/
+          field = "#{quote_table_name("comments")}.#{quote_column_name("id")}"
+          expect(sql).to match /#{field} IS NULL/
+          expect(sql).to match /AND NOT/
+        end
+      end
     end
 
     describe 'present' do
@@ -359,6 +419,20 @@ module Ransack
       end
     end
 
+    context "defining custom predicates" do
+      describe "with 'not_in' arel predicate" do
+        before do
+          Ransack.configure {|c| c.add_predicate "not_in_csv", arel_predicate: "not_in", formatter: proc { |v| v.split(",") } }
+        end
+
+        it 'generates a value IS NOT NULL query' do
+          @s.name_not_in_csv = ["a", "b"]
+          field = "#{quote_table_name("people")}.#{quote_column_name("name")}"
+          expect(@s.result.to_sql).to match /#{field} NOT IN \('a', 'b'\)/
+        end
+      end
+    end
+
     private
 
       def test_boolean_equality_for(boolean_value)

data/spec/ransack/search_spec.rb

@@ -20,6 +20,12 @@ module Ransack
         Search.new(Person, name_eq: 'foobar')
       end
 
+      it 'strip leading & trailing whitespace 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: [''])
@@ -43,16 +49,16 @@ module Ransack
 
       it 'accepts a context option' do
         shared_context = Context.for(Person)
-        search1 = Search.new(Person, { name_eq: 'A' }, context: shared_context)
-        search2 = Search.new(Person, { name_eq: 'B' }, context: shared_context)
-        expect(search1.context).to be search2.context
+        s1 = Search.new(Person, { name_eq: 'A' }, context: shared_context)
+        s2 = Search.new(Person, { name_eq: 'B' }, context: shared_context)
+        expect(s1.context).to be s2.context
       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]
+        s = Search.new(Person, name_eq: 'Ernie')
+        condition = s.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'
@@ -60,8 +66,8 @@ module Ransack
       end
 
       it 'creates conditions for association attributes' do
-        search = Search.new(Person, children_name_eq: 'Ernie')
-        condition = search.base[:children_name_eq]
+        s = Search.new(Person, children_name_eq: 'Ernie')
+        condition = s.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'
@@ -69,8 +75,8 @@ module Ransack
       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]
+        s = Search.new(Note, notable_of_Person_type_name_eq: 'Ernie')
+        condition = s.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)
@@ -80,9 +86,9 @@ module Ransack
 
       it 'creates conditions for multiple polymorphic belongs_to association
         attributes' do
-        search = Search.new(Note,
+        s = Search.new(Note,
           notable_of_Person_type_name_or_notable_of_Article_type_title_eq: 'Ernie')
-        condition = search.
+        condition = s.
           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'
@@ -93,14 +99,62 @@ module Ransack
         expect(condition.value).to eq 'Ernie'
       end
 
-      it 'preserves default scope conditions for associations' do
-        search = Search.new(Person, articles_title_eq: 'Test')
-        expect(search.result.to_sql).to include 'default_scope'
+      it 'creates conditions for aliased attributes',
+      if: Ransack::SUPPORTS_ATTRIBUTE_ALIAS do
+        s = Search.new(Person, full_name_eq: 'Ernie')
+        condition = s.base[:full_name_eq]
+        expect(condition).to be_a Nodes::Condition
+        expect(condition.predicate.name).to eq 'eq'
+        expect(condition.attributes.first.name).to eq 'full_name'
+        expect(condition.value).to eq 'Ernie'
+      end
+
+      it 'preserves default scope and conditions for associations' do
+        s = Search.new(Person, published_articles_title_eq: 'Test')
+        expect(s.result.to_sql).to include 'default_scope'
+        expect(s.result.to_sql).to include 'published'
+      end
+
+      # The failure/oversight in Ransack::Nodes::Condition#arel_predicate or deeper is beyond my understanding of the structures
+      it 'preserves (inverts) default scope and conditions for negative subqueries' do
+        # the positive case (published_articles_title_eq) is
+        # SELECT "people".* FROM "people"
+        # LEFT OUTER JOIN "articles" ON "articles"."person_id" = "people"."id"
+        #   AND "articles"."published" = 't'
+        #   AND ('default_scope' = 'default_scope')
+        # WHERE "articles"."title" = 'Test' ORDER BY "people"."id" DESC
+        #
+        # negative case was
+        # SELECT "people".* FROM "people" WHERE "people"."id" NOT IN (
+        #   SELECT "articles"."person_id" FROM "articles"
+        #   WHERE "articles"."person_id" = "people"."id"
+        #     AND NOT ("articles"."title" != 'Test')
+        # ) ORDER BY "people"."id" DESC
+        #
+        # Should have been like
+        # SELECT "people".* FROM "people" WHERE "people"."id" NOT IN (
+        #   SELECT "articles"."person_id" FROM "articles"
+        #   WHERE "articles"."person_id" = "people"."id"
+        #     AND "articles"."title" = 'Test' AND "articles"."published" = 't' AND ('default_scope' = 'default_scope')
+        # ) ORDER BY "people"."id" DESC
+        #
+        # With tenanting (eg default_scope with column reference), NOT IN should be like
+        # SELECT "people".* FROM "people" WHERE "people"."tenant_id" = 'tenant_id' AND "people"."id" NOT IN (
+        #   SELECT "articles"."person_id" FROM "articles"
+        #   WHERE "articles"."person_id" = "people"."id"
+        #     AND "articles"."tenant_id" = 'tenant_id'
+        #     AND "articles"."title" = 'Test' AND "articles"."published" = 't' AND ('default_scope' = 'default_scope')
+        # ) ORDER BY "people"."id" DESC
+
+        pending("spec should pass, but I do not know how/where to fix lib code")
+        s = Search.new(Person, published_articles_title_not_eq: 'Test')
+        expect(s.result.to_sql).to include 'default_scope'
+        expect(s.result.to_sql).to include 'published'
       end
 
       it 'discards empty conditions' do
-        search = Search.new(Person, children_name_eq: '')
-        condition = search.base[:children_name_eq]
+        s = Search.new(Person, children_name_eq: '')
+        condition = s.base[:children_name_eq]
         expect(condition).to be_nil
       end
 
@@ -110,13 +164,13 @@ module Ransack
       end
 
       it 'accepts arrays of groupings' do
-        search = Search.new(Person,
+        s = 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
+        ors = s.groupings
         expect(ors.size).to eq(2)
         or1, or2 = ors
         expect(or1).to be_a Nodes::Grouping
@@ -125,14 +179,14 @@ module Ransack
         expect(or2.combinator).to eq 'or'
       end
 
-      it 'accepts "attributes" hashes for groupings' do
-        search = Search.new(Person,
+      it 'accepts attributes hashes for groupings' do
+        s = 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
+        ors = s.groupings
         expect(ors.size).to eq(2)
         or1, or2 = ors
         expect(or1).to be_a Nodes::Grouping
@@ -141,8 +195,8 @@ module Ransack
         expect(or2.combinator).to eq 'or'
       end
 
-      it 'accepts "attributes" hashes for conditions' do
-        search = Search.new(Person,
+      it 'accepts attributes hashes for conditions' do
+        s = Search.new(Person,
           c: {
             '0' => { a: ['name'], p: 'eq', v: ['Ernie'] },
             '1' => {
@@ -151,7 +205,7 @@ module Ransack
                    }
           }
         )
-        conditions = search.base.conditions
+        conditions = s.base.conditions
         expect(conditions.size).to eq(2)
         expect(conditions.map { |c| c.class })
         .to eq [Nodes::Condition, Nodes::Condition]
@@ -162,8 +216,8 @@ module Ransack
           config.add_predicate 'ary_pred', wants_array: true
         end
 
-        search = Search.new(Person, name_ary_pred: ['Ernie', 'Bert'])
-        condition = search.base[:name_ary_pred]
+        s = Search.new(Person, name_ary_pred: ['Ernie', 'Bert'])
+        condition = s.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'
@@ -171,8 +225,8 @@ module Ransack
       end
 
       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/
+        s = Search.new(Person, children_id_in: [1, 2, 3])
+        expect(s.inspect).not_to match /ActiveRecord/
       end
 
       context 'with an invalid condition' do
@@ -209,62 +263,86 @@ module Ransack
       let(:children_people_name_field) {
         "#{quote_table_name("children_people")}.#{quote_column_name("name")}"
       }
+      let(:notable_type_field) {
+        "#{quote_table_name("notes")}.#{quote_column_name("notable_type")}"
+      }
       it 'evaluates conditions contextually' do
-        search = Search.new(Person, children_name_eq: 'Ernie')
-        expect(search.result).to be_an ActiveRecord::Relation
-        expect(search.result.to_sql).to match /#{
+        s = Search.new(Person, children_name_eq: 'Ernie')
+        expect(s.result).to be_an ActiveRecord::Relation
+        expect(s.result.to_sql).to match /#{
           children_people_name_field} = 'Ernie'/
       end
 
-      # FIXME: Make this spec pass for Rails 4.1 / 4.2 / 5.0 and not just 4.0 by
-      # commenting out lines 221 and 242 to run the test. Addresses issue #374.
-      # https://github.com/activerecord-hackery/ransack/issues/374
-      #
-      if ::ActiveRecord::VERSION::STRING.first(3) == '4.0'
-        it 'evaluates conditions for multiple belongs_to associations to the
-        same table contextually' do
-          s = Search.new(Recommendation,
-            person_name_eq: 'Ernie',
-            target_person_parent_name_eq: 'Test'
-          ).result
-          expect(s).to be_an ActiveRecord::Relation
-          real_query = remove_quotes_and_backticks(s.to_sql)
-          expected_query = <<-SQL
-            SELECT recommendations.* FROM recommendations
-            LEFT OUTER JOIN people ON people.id = recommendations.person_id
-            LEFT OUTER JOIN people target_people_recommendations
-              ON target_people_recommendations.id = recommendations.target_person_id
-            LEFT OUTER JOIN people parents_people
-              ON parents_people.id = target_people_recommendations.parent_id
-            WHERE ((people.name = 'Ernie' AND parents_people.name = 'Test'))
-          SQL
-          .squish
-          expect(real_query).to eq expected_query
-        end
+      it 'use appropriate table alias' do
+        skip "Rails 6 regressed here, but it's fixed in 6-0-stable since https://github.com/rails/rails/commit/f9ba52477ca288e7effa5f6794ae3df3f4e982bc" if ENV["RAILS"] == "v6.0.3"
+
+        s = Search.new(Person, {
+          name_eq: "person_name_query",
+          articles_title_eq: "person_article_title_query",
+          parent_name_eq: "parent_name_query",
+          parent_articles_title_eq: 'parents_article_title_query'
+        }).result
+
+        real_query = remove_quotes_and_backticks(s.to_sql)
+
+        expect(real_query)
+                .to match(%r{LEFT OUTER JOIN articles ON (\('default_scope' = 'default_scope'\) AND )?articles.person_id = people.id})
+        expect(real_query)
+                .to match(%r{LEFT OUTER JOIN articles articles_people ON (\('default_scope' = 'default_scope'\) AND )?articles_people.person_id = parents_people.id})
+
+        expect(real_query)
+          .to include "people.name = 'person_name_query'"
+        expect(real_query)
+          .to include "articles.title = 'person_article_title_query'"
+        expect(real_query)
+          .to include "parents_people.name = 'parent_name_query'"
+        expect(real_query)
+          .to include "articles_people.title = 'parents_article_title_query'"
+      end
+
+      it 'evaluates conditions for multiple `belongs_to` associations to the same table contextually' do
+        s = Search.new(
+          Recommendation,
+          person_name_eq: 'Ernie',
+          target_person_parent_name_eq: 'Test'
+        ).result
+        expect(s).to be_an ActiveRecord::Relation
+        real_query = remove_quotes_and_backticks(s.to_sql)
+        expected_query = <<-SQL
+          SELECT recommendations.* FROM recommendations
+          LEFT OUTER JOIN people ON people.id = recommendations.person_id
+          LEFT OUTER JOIN people target_people_recommendations
+            ON target_people_recommendations.id = recommendations.target_person_id
+          LEFT OUTER JOIN people parents_people
+            ON parents_people.id = target_people_recommendations.parent_id
+          WHERE (people.name = 'Ernie' AND parents_people.name = 'Test')
+        SQL
+        .squish
+        expect(real_query).to eq expected_query
       end
 
       it 'evaluates compound conditions contextually' do
-        search = Search.new(Person, children_name_or_name_eq: 'Ernie').result
-        expect(search).to be_an ActiveRecord::Relation
-        expect(search.to_sql).to match /#{children_people_name_field
+        s = Search.new(Person, children_name_or_name_eq: 'Ernie').result
+        expect(s).to be_an ActiveRecord::Relation
+        expect(s.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')
-        .result
-        expect(search).to be_an ActiveRecord::Relation
-        expect(search.to_sql).to match /#{people_name_field} = 'Ernie'/
+        s = Search.new(Note, notable_of_Person_type_name_eq: 'Ernie').result
+        expect(s).to be_an ActiveRecord::Relation
+        expect(s.to_sql).to match /#{people_name_field} = 'Ernie'/
+        expect(s.to_sql).to match /#{notable_type_field} = 'Person'/
       end
 
       it 'evaluates nested conditions' do
-        search = Search.new(Person, children_name_eq: 'Ernie',
+        s = Search.new(Person, children_name_eq: 'Ernie',
           g: [
             { m: 'or', name_eq: 'Ernie', children_children_name_eq: 'Ernie' }
           ]
         ).result
-        expect(search).to be_an ActiveRecord::Relation
-        first, last = search.to_sql.split(/ AND /)
+        expect(s).to be_an ActiveRecord::Relation
+        first, last = s.to_sql.split(/ AND /)
         expect(first).to match /#{children_people_name_field} = 'Ernie'/
         expect(last).to match /#{
           people_name_field} = 'Ernie' OR #{
@@ -273,14 +351,14 @@ module Ransack
       end
 
       it 'evaluates arrays of groupings' do
-        search = Search.new(Person,
+        s = Search.new(Person,
           g: [
             { m: 'or', name_eq: 'Ernie', children_name_eq: 'Ernie' },
             { m: 'or', name_eq: 'Bert', children_name_eq: 'Bert' }
           ]
         ).result
-        expect(search).to be_an ActiveRecord::Relation
-        first, last = search.to_sql.split(/ AND /)
+        expect(s).to be_an ActiveRecord::Relation
+        first, last = s.to_sql.split(/ AND /)
         expect(first).to match /#{people_name_field} = 'Ernie' OR #{
           children_people_name_field} = 'Ernie'/
         expect(last).to match /#{people_name_field} = 'Bert' OR #{
@@ -288,22 +366,24 @@ module Ransack
       end
 
       it 'returns distinct records when passed distinct: true' do
-        search = Search.new(Person,
+        s = 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)
+
+        all_or_load, uniq_or_distinct = :load, :distinct
+        expect(s.result.send(all_or_load).size)
         .to eq(9000)
-        expect(search.result(distinct: true).size)
+        expect(s.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)
+        expect(s.result.send(all_or_load).send(uniq_or_distinct))
+        .to eq s.result(distinct: true).send(all_or_load)
+      end
+
+      it 'evaluates joins with belongs_to join' do
+        s = Person.joins(:parent).ransack(parent_name_eq: 'Ernie').result(distinct: true)
+        expect(s).to be_an ActiveRecord::Relation
       end
 
       private