pg_search 2.1.2 → 2.3.6

data/spec/lib/pg_search/multisearch/rebuilder_spec.rb

@@ -1,19 +1,17 @@
-require "spec_helper"
+# frozen_string_literal: true
 
-def has_microsecond_precision?
-  (ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR >= 1) ||
-    (ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR == 0 && ActiveRecord::VERSION::TINY >= 1)
-end
+require "spec_helper"
 
+# rubocop:disable RSpec/NestedGroups
 describe PgSearch::Multisearch::Rebuilder do
-  with_table "pg_search_documents", {}, &DOCUMENTS_SCHEMA
+  with_table "pg_search_documents", &DOCUMENTS_SCHEMA
 
-  describe 'when intialized with a model that is not multisearchable' do
+  describe 'when initialized with a model that is not multisearchable' do
     with_model :not_multisearchable
 
     it 'raises an exception' do
       expect {
-        PgSearch::Multisearch::Rebuilder.new(NotMultisearchable)
+        described_class.new(NotMultisearchable)
       }.to raise_exception(
         PgSearch::Multisearch::ModelNotMultisearchable,
         "NotMultisearchable is not multisearchable. See PgSearch::ClassMethods#multisearchable"
@@ -23,10 +21,10 @@ describe PgSearch::Multisearch::Rebuilder do
 
   describe "#rebuild" do
     context "when the model defines .rebuild_pg_search_documents" do
-      context "and multisearchable is not conditional" do
+      context "when multisearchable is not conditional" do
         with_model :Model do
           model do
-            include PgSearch
+            include PgSearch::Model
             multisearchable
 
             def rebuild_pg_search_documents
@@ -34,14 +32,18 @@ describe PgSearch::Multisearch::Rebuilder do
           end
         end
 
-        it "should call .rebuild_pg_search_documents" do
-          rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
-          expect(Model).to receive(:rebuild_pg_search_documents)
-          rebuilder.rebuild
+        it "calls .rebuild_pg_search_documents" do
+          rebuilder = described_class.new(Model)
+
+          without_partial_double_verification do
+            allow(Model).to receive(:rebuild_pg_search_documents)
+            rebuilder.rebuild
+            expect(Model).to have_received(:rebuild_pg_search_documents)
+          end
         end
       end
 
-      context "and multisearchable is conditional" do
+      context "when multisearchable is conditional" do
         %i[if unless].each do |conditional_key|
           context "via :#{conditional_key}" do
             with_model :Model do
@@ -50,7 +52,7 @@ describe PgSearch::Multisearch::Rebuilder do
               end
 
               model do
-                include PgSearch
+                include PgSearch::Model
                 multisearchable conditional_key => :active?
 
                 def rebuild_pg_search_documents
@@ -58,10 +60,14 @@ describe PgSearch::Multisearch::Rebuilder do
               end
             end
 
-            it "should call .rebuild_pg_search_documents" do
-              rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
-              expect(Model).to receive(:rebuild_pg_search_documents)
-              rebuilder.rebuild
+            it "calls .rebuild_pg_search_documents" do
+              rebuilder = described_class.new(Model)
+
+              without_partial_double_verification do
+                allow(Model).to receive(:rebuild_pg_search_documents)
+                rebuilder.rebuild
+                expect(Model).to have_received(:rebuild_pg_search_documents)
+              end
             end
           end
         end
@@ -69,7 +75,7 @@ describe PgSearch::Multisearch::Rebuilder do
     end
 
     context "when the model does not define .rebuild_pg_search_documents" do
-      context "and multisearchable is not conditional" do
+      context "when multisearchable is not conditional" do
         context "when :against only includes columns" do
           with_model :Model do
             table do |t|
@@ -77,13 +83,13 @@ describe PgSearch::Multisearch::Rebuilder do
             end
 
             model do
-              include PgSearch
-              multisearchable :against => :name
+              include PgSearch::Model
+              multisearchable against: :name
             end
           end
 
-          it "should not call :rebuild_pg_search_documents" do
-            rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
+          it "does not call :rebuild_pg_search_documents" do
+            rebuilder = described_class.new(Model)
 
             # stub respond_to? to return false since should_not_receive defines the method
             original_respond_to = Model.method(:respond_to?)
@@ -95,28 +101,28 @@ describe PgSearch::Multisearch::Rebuilder do
               end
             end
 
-            expect(Model).not_to receive(:rebuild_pg_search_documents)
-            rebuilder.rebuild
+            without_partial_double_verification do
+              allow(Model).to receive(:rebuild_pg_search_documents)
+              rebuilder.rebuild
+              expect(Model).not_to have_received(:rebuild_pg_search_documents)
+            end
           end
 
-          it "should execute the default SQL" do
+          # rubocop:disable RSpec/ExampleLength
+          it "executes the default SQL" do
             time = Time.utc(2001, 1, 1, 0, 0, 0)
-            rebuilder = PgSearch::Multisearch::Rebuilder.new(Model, -> { time })
-
-            # Handle change in precision of Time objects in SQL in Active Record 4.0.1
-            # https://github.com/rails/rails/commit/17f5d8e062909f1fcae25351834d8e89967b645e
-            expected_timestamp = has_microsecond_precision? ? "2001-01-01 00:00:00.000000" : "2001-01-01 00:00:00"
-
-            expected_sql = <<-SQL.strip_heredoc
-            INSERT INTO "pg_search_documents" (searchable_type, searchable_id, content, created_at, updated_at)
-              SELECT 'Model' AS searchable_type,
-                     #{Model.quoted_table_name}.#{Model.primary_key} AS searchable_id,
-                     (
-                       coalesce(#{Model.quoted_table_name}.name::text, '')
-                     ) AS content,
-                     '#{expected_timestamp}' AS created_at,
-                     '#{expected_timestamp}' AS updated_at
-              FROM #{Model.quoted_table_name}
+            rebuilder = described_class.new(Model, -> { time })
+
+            expected_sql = <<~SQL.squish
+              INSERT INTO "pg_search_documents" (searchable_type, searchable_id, content, created_at, updated_at)
+                SELECT 'Model' AS searchable_type,
+                       #{Model.quoted_table_name}.#{Model.primary_key} AS searchable_id,
+                       (
+                         coalesce(#{Model.quoted_table_name}."name"::text, '')
+                       ) AS content,
+                       '2001-01-01 00:00:00' AS created_at,
+                       '2001-01-01 00:00:00' AS updated_at
+                FROM #{Model.quoted_table_name}
             SQL
 
             executed_sql = []
@@ -131,37 +137,54 @@ describe PgSearch::Multisearch::Rebuilder do
             expect(executed_sql.length).to eq(1)
             expect(executed_sql.first.strip).to eq(expected_sql.strip)
           end
+          # rubocop:enable RSpec/ExampleLength
 
-          context "for a model with a non-standard primary key" do
+          context "with a model with a camel case column" do
+            with_model :ModelWithCamelCaseColumn do
+              table do |t|
+                t.string :camelName
+              end
+
+              model do
+                include PgSearch::Model
+                multisearchable against: :name
+              end
+            end
+
+            it "creates search document without PG error" do
+              time = Time.utc(2001, 1, 1, 0, 0, 0)
+              rebuilder = described_class.new(Model, -> { time })
+              rebuilder.rebuild
+            end
+          end
+
+          context "with a model with a non-standard primary key" do
             with_model :ModelWithNonStandardPrimaryKey do
               table primary_key: :non_standard_primary_key do |t|
                 t.string :name
               end
 
               model do
-                include PgSearch
-                multisearchable :against => :name
+                include PgSearch::Model
+                multisearchable against: :name
               end
             end
 
+            # rubocop:disable RSpec/ExampleLength
             it "generates SQL with the correct primary key" do
               time = Time.utc(2001, 1, 1, 0, 0, 0)
-              rebuilder = PgSearch::Multisearch::Rebuilder.new(ModelWithNonStandardPrimaryKey, -> { time })
-
-              # Handle change in precision of Time objects in SQL in Active Record 4.0.1
-              # https://github.com/rails/rails/commit/17f5d8e062909f1fcae25351834d8e89967b645e
-              expected_timestamp = has_microsecond_precision? ? "2001-01-01 00:00:00.000000" : "2001-01-01 00:00:00"
-
-              expected_sql = <<-SQL.strip_heredoc
-              INSERT INTO "pg_search_documents" (searchable_type, searchable_id, content, created_at, updated_at)
-                SELECT 'ModelWithNonStandardPrimaryKey' AS searchable_type,
-                       #{ModelWithNonStandardPrimaryKey.quoted_table_name}.non_standard_primary_key AS searchable_id,
-                       (
-                         coalesce(#{ModelWithNonStandardPrimaryKey.quoted_table_name}.name::text, '')
-                       ) AS content,
-                       '#{expected_timestamp}' AS created_at,
-                       '#{expected_timestamp}' AS updated_at
-                FROM #{ModelWithNonStandardPrimaryKey.quoted_table_name}
+              rebuilder = described_class.new(ModelWithNonStandardPrimaryKey, -> { time })
+
+              expected_sql = <<~SQL.squish
+                INSERT INTO "pg_search_documents" (searchable_type, searchable_id, content, created_at, updated_at)
+                  SELECT 'ModelWithNonStandardPrimaryKey' AS searchable_type,
+                         #{ModelWithNonStandardPrimaryKey.quoted_table_name}.non_standard_primary_key AS searchable_id,
+                         (
+                           coalesce(#{ModelWithNonStandardPrimaryKey.quoted_table_name}."name"::text, '')
+                         ) AS content,
+                         '2001-01-01 00:00:00' AS created_at,
+                         '2001-01-01 00:00:00' AS updated_at
+                  FROM #{ModelWithNonStandardPrimaryKey.quoted_table_name}
               SQL
 
               executed_sql = []
@@ -176,16 +199,14 @@ describe PgSearch::Multisearch::Rebuilder do
               expect(executed_sql.length).to eq(1)
               expect(executed_sql.first.strip).to eq(expected_sql.strip)
             end
+            # rubocop:enable RSpec/ExampleLength
           end
         end
 
         context "when :against includes non-column dynamic methods" do
           with_model :Model do
-            table do
-            end
-
             model do
-              include PgSearch
+              include PgSearch::Model
               multisearchable against: [:foo]
 
               def foo
@@ -194,10 +215,11 @@ describe PgSearch::Multisearch::Rebuilder do
             end
           end
 
+          # rubocop:disable RSpec/ExampleLength
           it "calls update_pg_search_document on each record" do
             record = Model.create!
 
-            rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
+            rebuilder = described_class.new(Model)
 
             # stub respond_to? to return false since should_not_receive defines the method
             original_respond_to = Model.method(:respond_to?)
@@ -208,16 +230,49 @@ describe PgSearch::Multisearch::Rebuilder do
                 original_respond_to.call(method_name, *args)
               end
             end
-            expect(Model).not_to receive(:rebuild_pg_search_documents)
 
-            rebuilder.rebuild
+            without_partial_double_verification do
+              allow(Model).to receive(:rebuild_pg_search_documents)
+
+              rebuilder.rebuild
+
+              expect(Model).not_to have_received(:rebuild_pg_search_documents)
+            end
 
             expect(record.pg_search_document).to be_present
           end
+          # rubocop:enable RSpec/ExampleLength
+        end
+
+        context "when only additional_attributes is set" do
+          with_model :Model do
+            table do |t|
+              t.string :name
+            end
+
+            model do
+              include PgSearch::Model
+              multisearchable against: :name,
+                              additional_attributes: ->(obj) { { additional_attribute_column: "#{obj.class}::#{obj.id}" } }
+            end
+          end
+
+          it "calls update_pg_search_document on each record" do
+            record_1 = Model.create!(name: "record_1", id: 1)
+            record_2 = Model.create!(name: "record_2", id: 2)
+
+            PgSearch::Document.delete_all
+
+            rebuilder = described_class.new(Model)
+            rebuilder.rebuild
+
+            expect(record_1.reload.pg_search_document.additional_attribute_column).to eq("Model::1")
+            expect(record_2.reload.pg_search_document.additional_attribute_column).to eq("Model::2")
+          end
         end
       end
 
-      context "and multisearchable is conditional" do
+      context "when multisearchable is conditional" do
         context "via :if" do
           with_model :Model do
             table do |t|
@@ -225,16 +280,17 @@ describe PgSearch::Multisearch::Rebuilder do
             end
 
             model do
-              include PgSearch
-              multisearchable :if => :active?
+              include PgSearch::Model
+              multisearchable if: :active?
             end
           end
 
+          # rubocop:disable RSpec/ExampleLength
           it "calls update_pg_search_document on each record" do
-            record_1 = Model.create!(:active => true)
-            record_2 = Model.create!(:active => false)
+            record_1 = Model.create!(active: true)
+            record_2 = Model.create!(active: false)
 
-            rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
+            rebuilder = described_class.new(Model)
 
             # stub respond_to? to return false since should_not_receive defines the method
             original_respond_to = Model.method(:respond_to?)
@@ -245,13 +301,17 @@ describe PgSearch::Multisearch::Rebuilder do
                 original_respond_to.call(method_name, *args)
               end
             end
-            expect(Model).not_to receive(:rebuild_pg_search_documents)
 
-            rebuilder.rebuild
+            without_partial_double_verification do
+              allow(Model).to receive(:rebuild_pg_search_documents)
+              rebuilder.rebuild
+              expect(Model).not_to have_received(:rebuild_pg_search_documents)
+            end
 
             expect(record_1.pg_search_document).to be_present
             expect(record_2.pg_search_document).not_to be_present
           end
+          # rubocop:enable RSpec/ExampleLength
         end
 
         context "via :unless" do
@@ -261,16 +321,17 @@ describe PgSearch::Multisearch::Rebuilder do
             end
 
             model do
-              include PgSearch
-              multisearchable :unless => :inactive?
+              include PgSearch::Model
+              multisearchable unless: :inactive?
             end
           end
 
+          # rubocop:disable RSpec/ExampleLength
           it "calls update_pg_search_document on each record" do
-            record_1 = Model.create!(:inactive => true)
-            record_2 = Model.create!(:inactive => false)
+            record_1 = Model.create!(inactive: true)
+            record_2 = Model.create!(inactive: false)
 
-            rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
+            rebuilder = described_class.new(Model)
 
             # stub respond_to? to return false since should_not_receive defines the method
             original_respond_to = Model.method(:respond_to?)
@@ -281,15 +342,20 @@ describe PgSearch::Multisearch::Rebuilder do
                 original_respond_to.call(method_name, *args)
               end
             end
-            expect(Model).not_to receive(:rebuild_pg_search_documents)
 
-            rebuilder.rebuild
+            without_partial_double_verification do
+              allow(Model).to receive(:rebuild_pg_search_documents)
+              rebuilder.rebuild
+              expect(Model).not_to have_received(:rebuild_pg_search_documents)
+            end
 
             expect(record_1.pg_search_document).not_to be_present
             expect(record_2.pg_search_document).to be_present
           end
+          # rubocop:enable RSpec/ExampleLength
         end
       end
     end
   end
 end
+# rubocop:enable RSpec/NestedGroups

data/spec/lib/pg_search/multisearch_spec.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 require "spec_helper"
+require "active_support/deprecation"
 
+# rubocop:disable RSpec/NestedGroups
 describe PgSearch::Multisearch do
-  with_table "pg_search_documents", {}, &DOCUMENTS_SCHEMA
+  with_table "pg_search_documents", &DOCUMENTS_SCHEMA
 
   with_model :MultisearchableModel do
     table do |t|
@@ -10,28 +14,37 @@ describe PgSearch::Multisearch do
       t.timestamps null: false
     end
     model do
-      include PgSearch
+      include PgSearch::Model
     end
   end
 
   let(:model) { MultisearchableModel }
   let(:connection) { model.connection }
-  let(:documents) { double(:documents) }
 
   describe ".rebuild" do
     before do
-      model.multisearchable :against => :title
+      model.multisearchable against: :title
     end
 
-    it "should operate inside a transaction" do
-      expect(model).to receive(:transaction).once
+    it "operates inside a transaction" do
+      allow(model).to receive(:transaction)
+
+      described_class.rebuild(model)
+      expect(model).to have_received(:transaction).once
+    end
 
-      PgSearch::Multisearch.rebuild(model)
+    context "when transactional is false" do
+      it "does not operate inside a transaction" do
+        allow(model).to receive(:transaction)
+
+        described_class.rebuild(model, transactional: false)
+        expect(model).not_to have_received(:transaction)
+      end
     end
 
     describe "cleaning up search documents for this model" do
       before do
-        connection.execute <<-SQL.strip_heredoc
+        connection.execute <<~SQL.squish
           INSERT INTO pg_search_documents
             (searchable_type, searchable_id, content, created_at, updated_at)
             VALUES
@@ -45,28 +58,39 @@ describe PgSearch::Multisearch do
       end
 
       context "when clean_up is not passed" do
-        it "should delete the document for the model" do
-          PgSearch::Multisearch.rebuild(model)
+        it "deletes the document for the model" do
+          described_class.rebuild(model)
           expect(PgSearch::Document.count).to eq(1)
           expect(PgSearch::Document.first.searchable_type).to eq("Bar")
         end
       end
 
       context "when clean_up is true" do
-        let(:clean_up) { true }
-
-        it "should delete the document for the model" do
-          PgSearch::Multisearch.rebuild(model, clean_up)
+        it "deletes the document for the model" do
+          described_class.rebuild(model, clean_up: true)
           expect(PgSearch::Document.count).to eq(1)
           expect(PgSearch::Document.first.searchable_type).to eq("Bar")
         end
       end
 
       context "when clean_up is false" do
-        let(:clean_up) { false }
+        it "does not delete the document for the model" do
+          described_class.rebuild(model, clean_up: false)
+          expect(PgSearch::Document.count).to eq(2)
+        end
+      end
 
-        it "should not delete the document for the model" do
-          PgSearch::Multisearch.rebuild(model, clean_up)
+      context "when deprecated_clean_up is true" do
+        it "deletes the document for the model" do
+          ActiveSupport::Deprecation.silence { described_class.rebuild(model, true) }
+          expect(PgSearch::Document.count).to eq(1)
+          expect(PgSearch::Document.first.searchable_type).to eq("Bar")
+        end
+      end
+
+      context "when deprecated_clean_up is false" do
+        it "does not delete the document for the model" do
+          ActiveSupport::Deprecation.silence { described_class.rebuild(model, false) }
           expect(PgSearch::Document.count).to eq(2)
         end
       end
@@ -74,7 +98,7 @@ describe PgSearch::Multisearch do
       context "when the model implements .rebuild_pg_search_documents" do
         before do
           def model.rebuild_pg_search_documents
-            connection.execute <<-SQL.strip_heredoc
+            connection.execute <<~SQL.squish
               INSERT INTO pg_search_documents
                 (searchable_type, searchable_id, content, created_at, updated_at)
                 VALUES
@@ -83,45 +107,50 @@ describe PgSearch::Multisearch do
           end
         end
 
-        it "should call .rebuild_pg_search_documents and skip the default behavior" do
-          expect(PgSearch::Multisearch).not_to receive(:rebuild_sql)
-          PgSearch::Multisearch.rebuild(model)
+        it "calls .rebuild_pg_search_documents and skips the default behavior" do
+          without_partial_double_verification do
+            allow(model).to receive(:rebuild_sql)
+            described_class.rebuild(model)
 
-          record = PgSearch::Document.find_by_searchable_type_and_searchable_id("Baz", 789)
-          expect(record.content).to eq("baz")
+            record = PgSearch::Document.find_by(searchable_type: "Baz", searchable_id: 789)
+            expect(model).not_to have_received(:rebuild_sql)
+            expect(record.content).to eq("baz")
+          end
         end
       end
     end
 
     describe "inserting the new documents" do
       let!(:new_models) { [] }
+
       before do
-        new_models << model.create!(:title => "Foo", :content => "Bar")
-        new_models << model.create!(:title => "Baz", :content => "Bar")
+        new_models << model.create!(title: "Foo", content: "Bar")
+        new_models << model.create!(title: "Baz", content: "Bar")
       end
 
-      it "should create new documents for the two models" do
-        PgSearch::Multisearch.rebuild(model)
+      it "creates new documents for the two models" do
+        described_class.rebuild(model)
         expect(PgSearch::Document.last(2).map(&:searchable).map(&:title)).to match_array(new_models.map(&:title))
       end
     end
 
     describe "the generated SQL" do
       let(:now) { Time.now }
+
       before { allow(Time).to receive(:now).and_return(now) }
 
       context "with one attribute" do
         before do
-          model.multisearchable :against => [:title]
+          model.multisearchable against: [:title]
         end
 
-        it "should generate the proper SQL code" do
-          expected_sql = <<-SQL.strip_heredoc
+        it "generates the proper SQL code" do
+          expected_sql = <<~SQL.squish
             INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable_id, content, created_at, updated_at)
               SELECT #{connection.quote(model.name)} AS searchable_type,
                      #{model.quoted_table_name}.id AS searchable_id,
                      (
-                       coalesce(#{model.quoted_table_name}.title::text, '')
+                       coalesce(#{model.quoted_table_name}."title"::text, '')
                      ) AS content,
                      #{connection.quote(connection.quoted_date(now))} AS created_at,
                      #{connection.quote(connection.quoted_date(now))} AS updated_at
@@ -131,7 +160,7 @@ describe PgSearch::Multisearch do
           statements = []
           allow(connection).to receive(:execute) { |sql| statements << sql.strip }
 
-          PgSearch::Multisearch.rebuild(model)
+          described_class.rebuild(model)
 
           expect(statements).to include(expected_sql.strip)
         end
@@ -139,16 +168,16 @@ describe PgSearch::Multisearch do
 
       context "with multiple attributes" do
         before do
-          model.multisearchable :against => %i[title content]
+          model.multisearchable against: %i[title content]
         end
 
-        it "should generate the proper SQL code" do
-          expected_sql = <<-SQL.strip_heredoc
+        it "generates the proper SQL code" do
+          expected_sql = <<~SQL.squish
             INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable_id, content, created_at, updated_at)
               SELECT #{connection.quote(model.name)} AS searchable_type,
                      #{model.quoted_table_name}.id AS searchable_id,
                      (
-                       coalesce(#{model.quoted_table_name}.title::text, '') || ' ' || coalesce(#{model.quoted_table_name}.content::text, '')
+                       coalesce(#{model.quoted_table_name}."title"::text, '') || ' ' || coalesce(#{model.quoted_table_name}."content"::text, '')
                      ) AS content,
                      #{connection.quote(connection.quoted_date(now))} AS created_at,
                      #{connection.quote(connection.quoted_date(now))} AS updated_at
@@ -158,7 +187,7 @@ describe PgSearch::Multisearch do
           statements = []
           allow(connection).to receive(:execute) { |sql| statements << sql.strip }
 
-          PgSearch::Multisearch.rebuild(model)
+          described_class.rebuild(model)
 
           expect(statements).to include(expected_sql.strip)
         end
@@ -166,3 +195,4 @@ describe PgSearch::Multisearch do
     end
   end
 end
+# rubocop:enable RSpec/NestedGroups