pg_search 2.3.7 → 2.4.0

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

@@ -7,14 +7,16 @@ describe PgSearch::Multisearch::Rebuilder do
   with_table "pg_search_documents", &DOCUMENTS_SCHEMA
 
   describe "when initialized with a model that is not multisearchable" do
-    with_model :not_multisearchable
+    with_model :NotSearchable do
+      table
+    end
 
     it "raises an exception" do
       expect {
-        described_class.new(NotMultisearchable)
+        described_class.new(NotSearchable)
       }.to raise_exception(
         PgSearch::Multisearch::ModelNotMultisearchable,
-        "NotMultisearchable is not multisearchable. See PgSearch::ClassMethods#multisearchable"
+        "NotSearchable is not multisearchable. See PgSearch::ClassMethods#multisearchable"
       )
     end
   end
@@ -22,52 +24,52 @@ describe PgSearch::Multisearch::Rebuilder do
   describe "#rebuild" do
     context "when the model defines .rebuild_pg_search_documents" do
       context "when multisearchable is not conditional" do
-        with_model :Model do
+        with_model :Book do
+          table
+
           model do
             include PgSearch::Model
+
             multisearchable
 
-            def rebuild_pg_search_documents
-            end
+            class_attribute :documents_rebuilt, default: false
+
+            def self.rebuild_pg_search_documents = self.documents_rebuilt = true
           end
         end
 
-        it "calls .rebuild_pg_search_documents" do
-          rebuilder = described_class.new(Model)
+        it "dispatches to .rebuild_pg_search_documents" do
+          described_class.new(Book).rebuild
 
-          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
+          expect(Book.documents_rebuilt).to be true
         end
       end
 
       context "when multisearchable is conditional" do
-        %i[if unless].each do |conditional_key|
-          context "via :#{conditional_key}" do
-            with_model :Model do
+        %i[if unless].each do |key|
+          context "via :#{key}" do
+            with_model :Book do
               table do |t|
                 t.boolean :active
               end
 
               model do
                 include PgSearch::Model
-                multisearchable conditional_key => :active?
 
-                def rebuild_pg_search_documents
+                multisearchable key => :active?
+
+                class_attribute :documents_rebuilt, default: false
+
+                def self.rebuild_pg_search_documents
+                  self.documents_rebuilt = true
                 end
               end
             end
 
-            it "calls .rebuild_pg_search_documents" do
-              rebuilder = described_class.new(Model)
+            it "dispatches to .rebuild_pg_search_documents" do
+              described_class.new(Book).rebuild
 
-              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
+              expect(Book.documents_rebuilt).to be true
             end
           end
         end
@@ -77,282 +79,320 @@ describe PgSearch::Multisearch::Rebuilder do
     context "when the model does not define .rebuild_pg_search_documents" do
       context "when multisearchable is not conditional" do
         context "when :against only includes columns" do
-          with_model :Model do
+          with_model :Book do
             table do |t|
-              t.string :name
+              t.string :title
             end
 
             model do
               include PgSearch::Model
-              multisearchable against: :name
+
+              multisearchable against: :title
             end
           end
 
-          it "does not call :rebuild_pg_search_documents" do
-            rebuilder = described_class.new(Model)
+          it "inserts a document for each record via bulk INSERT" do
+            book = PgSearch.disable_multisearch { Book.create!(title: "Dune") }
 
-            # stub respond_to? to return false since should_not_receive defines the method
-            original_respond_to = Model.method(:respond_to?)
-            allow(Model).to receive(:respond_to?) do |method_name, *args|
-              if method_name == :rebuild_pg_search_documents
-                false
-              else
-                original_respond_to.call(method_name, *args)
-              end
-            end
+            described_class.new(Book).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
+            document = book.pg_search_document
+            expect(document.searchable_type).to eq("Book")
+            expect(document.searchable_id).to eq(book.id)
+            expect(document.content).to eq("Dune")
           end
 
-          # standard:disable RSpec/ExampleLength
-          it "executes the default SQL" do
-            time = Time.utc(2001, 1, 1, 0, 0, 0)
-            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 = []
-
-            notifier = ActiveSupport::Notifications.subscribe("sql.active_record") do |_name, _start, _finish, _id, payload|
-              executed_sql << payload[:sql] if payload[:sql].include?(%(INSERT INTO "pg_search_documents"))
-            end
+          it "coalesces NULL column values to empty string" do
+            book = PgSearch.disable_multisearch { Book.create!(title: nil) }
 
-            rebuilder.rebuild
-            ActiveSupport::Notifications.unsubscribe(notifier)
+            described_class.new(Book).rebuild
 
-            expect(executed_sql.length).to eq(1)
-            expect(executed_sql.first.strip).to eq(expected_sql.strip)
+            expect(book.pg_search_document.content).to eq("")
           end
-          # standard:enable RSpec/ExampleLength
 
-          context "with a model with a camel case column" do
-            with_model :ModelWithCamelCaseColumn do
-              table do |t|
-                t.string :camelName
-              end
+          it "stamps both timestamps with the precision and offset of one clock call" do
+            time = Time.iso8601("2001-01-01T06:30:00.123456+05:30")
+            call_count = 0
+            time_source = lambda do
+              call_count += 1
+              time
+            end
 
-              model do
-                include PgSearch::Model
-                multisearchable against: :name
-              end
+            book = PgSearch.disable_multisearch { Book.create!(title: "Dune") }
+
+            described_class.new(Book, time_source).rebuild
+
+            expect(call_count).to eq(1)
+            document = book.pg_search_document
+            expect(document.created_at).to eq(time)
+            expect(document.updated_at).to eq(time)
+          end
+        end
+
+        context "when :against includes multiple columns" do
+          with_model :Book do
+            table do |t|
+              t.string :title
+              t.text :body
             end
 
-            it "rebuilds without error" do
-              time = Time.utc(2001, 1, 1, 0, 0, 0)
-              rebuilder = described_class.new(Model, -> { time })
-              expect { rebuilder.rebuild }.not_to raise_error
+            model do
+              include PgSearch::Model
+
+              multisearchable against: %i[title body]
             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
+          it "joins column values with a space" do
+            book = PgSearch.disable_multisearch { Book.create!(title: "Dune", body: "The spice") }
 
-              model do
-                include PgSearch::Model
-                multisearchable against: :name
-              end
-            end
+            described_class.new(Book).rebuild
 
-            # standard:disable RSpec/ExampleLength
-            it "generates SQL with the correct primary key" do
-              time = Time.utc(2001, 1, 1, 0, 0, 0)
-              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 = []
-
-              notifier = ActiveSupport::Notifications.subscribe("sql.active_record") do |_name, _start, _finish, _id, payload|
-                executed_sql << payload[:sql] if payload[:sql].include?(%(INSERT INTO "pg_search_documents"))
-              end
+            expect(book.pg_search_document.content).to eq("Dune The spice")
+          end
 
-              rebuilder.rebuild
-              ActiveSupport::Notifications.unsubscribe(notifier)
+          it "coalesces NULL in any column to empty string" do
+            book = PgSearch.disable_multisearch { Book.create!(title: "Dune", body: nil) }
 
-              expect(executed_sql.length).to eq(1)
-              expect(executed_sql.first.strip).to eq(expected_sql.strip)
-            end
-            # standard:enable RSpec/ExampleLength
+            described_class.new(Book).rebuild
+
+            # Keep the separator when the NULL body becomes an empty string.
+            expect(book.pg_search_document.content).to eq("Dune ")
           end
         end
 
-        context "when :against includes non-column dynamic methods" do
-          with_model :Model do
+        context "with a camelCase column name" do
+          with_model :Book do
+            table do |t|
+              t.string :camelName
+            end
+
             model do
               include PgSearch::Model
-              multisearchable against: [:foo]
 
-              def foo
-                "bar"
-              end
+              multisearchable against: :camelName
             end
           end
 
-          # standard:disable RSpec/ExampleLength
-          it "calls update_pg_search_document on each record" do
-            record = Model.create!
+          it "quotes the column name and inserts correct content" do
+            book = PgSearch.disable_multisearch { Book.create!(camelName: "CamelValue") }
 
-            rebuilder = described_class.new(Model)
+            described_class.new(Book).rebuild
 
-            # stub respond_to? to return false since should_not_receive defines the method
-            original_respond_to = Model.method(:respond_to?)
-            allow(Model).to receive(:respond_to?) do |method_name, *args|
-              if method_name == :rebuild_pg_search_documents
-                false
-              else
-                original_respond_to.call(method_name, *args)
-              end
-            end
+            expect(book.pg_search_document.content).to eq("CamelValue")
+          end
+        end
 
-            without_partial_double_verification do
-              allow(Model).to receive(:rebuild_pg_search_documents)
+        context "with a non-standard primary key" do
+          with_model :Book do
+            table primary_key: :isbn do |t|
+              t.string :title
+            end
 
-              rebuilder.rebuild
+            model do
+              include PgSearch::Model
 
-              expect(Model).not_to have_received(:rebuild_pg_search_documents)
+              multisearchable against: :title
             end
+          end
 
-            expect(record.pg_search_document).to be_present
+          it "stores the non-standard primary key in searchable_id" do
+            book = PgSearch.disable_multisearch { Book.create!(title: "Dune") }
+
+            described_class.new(Book).rebuild
+
+            expect(book.pg_search_document.searchable_id).to eq(book.isbn)
           end
-          # standard:enable RSpec/ExampleLength
         end
 
-        context "when only additional_attributes is set" do
-          with_model :Model do
+        context "with an identifier that requires quoting" do
+          with_model :Book do
             table do |t|
-              t.string :name
+              t.string :title
             end
 
             model do
               include PgSearch::Model
-              multisearchable against: :name,
-                additional_attributes: ->(obj) { {additional_attribute_column: "#{obj.class}::#{obj.id}"} }
+
+              multisearchable against: :title
             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)
+          it "quotes a malicious primary key in the generated SQL" do
+            malicious_pk = %(id"; DROP TABLE pg_search_documents; --)
+            allow(Book).to receive(:primary_key).and_return(malicious_pk)
 
-            PgSearch::Document.delete_all
+            sql = described_class.new(Book).send(:rebuild_sql)
+
+            expect(sql).to include(Book.connection.quote_column_name(malicious_pk))
+          end
+
+          it "quotes a malicious inheritance column in the generated SQL" do
+            malicious_column = %(type"; DROP TABLE pg_search_documents; --)
+            allow(Book).to receive(:inheritance_column).and_return(malicious_column)
+            allow(Book).to receive(:column_names).and_return(Book.column_names + [malicious_column])
 
-            rebuilder = described_class.new(Model)
-            rebuilder.rebuild
+            sql = described_class.new(Book).send(:rebuild_sql)
 
-            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")
+            expect(sql).to include(Book.connection.quote_column_name(malicious_column))
           end
         end
-      end
 
-      context "when multisearchable is conditional" do
-        context "via :if" do
-          with_model :Model do
+        context "with STI" do
+          with_model :Animal do
             table do |t|
-              t.boolean :active
+              t.string :type
+              t.string :name
             end
 
             model do
               include PgSearch::Model
-              multisearchable if: :active?
+
+              multisearchable against: :name
             end
           end
 
-          # standard: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)
+          with_model :Cat, superclass: :Animal do
+            table(false)
 
-            rebuilder = described_class.new(Model)
+            model do
+              include PgSearch::Model
 
-            # stub respond_to? to return false since should_not_receive defines the method
-            original_respond_to = Model.method(:respond_to?)
-            allow(Model).to receive(:respond_to?) do |method_name, *args|
-              if method_name == :rebuild_pg_search_documents
-                false
-              else
-                original_respond_to.call(method_name, *args)
-              end
+              multisearchable against: :name
             end
+          end
 
-            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
+          it "rebuilds base class documents for null-typed rows only" do
+            base = PgSearch.disable_multisearch { Animal.create!(name: "Base") }
+            PgSearch.disable_multisearch { Cat.create!(name: "Whiskers") }
+
+            described_class.new(Animal).rebuild
+
+            # Only the directly-typed Animal row is included; Cat rows require their own rebuild
+            ids = PgSearch::Document.where(searchable_type: "Animal").map(&:searchable_id)
+            expect(ids).to contain_exactly(base.id)
+          end
+
+          it "rebuilds subclass documents with exact type match" do
+            PgSearch.disable_multisearch { Animal.create!(name: "Base") }
+            cat = PgSearch.disable_multisearch { Cat.create!(name: "Whiskers") }
+
+            described_class.new(Cat).rebuild
+
+            # Cat rebuild stores searchable_type = base class name
+            ids = PgSearch::Document.where(searchable_type: "Animal").map(&:searchable_id)
+            expect(ids).to contain_exactly(cat.id)
+          end
 
-            expect(record_1.pg_search_document).to be_present
-            expect(record_2.pg_search_document).not_to be_present
+          it "stores base_class.name as searchable_type for subclass rows" do
+            cat = PgSearch.disable_multisearch { Cat.create!(name: "Whiskers") }
+
+            described_class.new(Cat).rebuild
+
+            document = PgSearch::Document.find_by!(searchable_id: cat.id, searchable_type: "Animal")
+            expect(document.content).to eq("Whiskers")
           end
-          # standard:enable RSpec/ExampleLength
         end
+      end
 
-        context "via :unless" do
-          with_model :Model do
+      context "when :against includes non-column dynamic methods" do
+        with_model :Book do
+          table
+
+          model do
+            include PgSearch::Model
+
+            multisearchable against: [:summary]
+
+            def summary = "dynamic"
+          end
+        end
+
+        it "falls back to find_each and creates a document per record" do
+          book = PgSearch.disable_multisearch { Book.create! }
+          PgSearch::Document.delete_all
+
+          described_class.new(Book).rebuild
+
+          expect(book.pg_search_document).to be_present
+        end
+      end
+
+      context "when only additional_attributes is set" do
+        with_model :Book do
+          table do |t|
+            t.string :title
+          end
+
+          model do
+            include PgSearch::Model
+
+            multisearchable against: :title,
+              additional_attributes: ->(obj) { {additional_attribute_column: "#{obj.class}::#{obj.id}"} }
+          end
+        end
+
+        it "falls back to find_each and populates additional attributes" do
+          book1 = PgSearch.disable_multisearch { Book.create!(title: "Dune") }
+          book2 = PgSearch.disable_multisearch { Book.create!(title: "Foundation") }
+          PgSearch::Document.delete_all
+
+          described_class.new(Book).rebuild
+
+          expect(book1.reload.pg_search_document.additional_attribute_column).to eq("Book::#{book1.id}")
+          expect(book2.reload.pg_search_document.additional_attribute_column).to eq("Book::#{book2.id}")
+        end
+      end
+
+      context "when multisearchable is conditional" do
+        context "via :if" do
+          with_model :Book do
             table do |t|
-              t.boolean :inactive
+              t.boolean :published
             end
 
             model do
               include PgSearch::Model
-              multisearchable unless: :inactive?
+
+              multisearchable if: :published?
             end
           end
 
-          # standard: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)
+          it "falls back to find_each and only creates documents for matching records" do
+            pub = PgSearch.disable_multisearch { Book.create!(published: true) }
+            draft = PgSearch.disable_multisearch { Book.create!(published: false) }
+            PgSearch::Document.delete_all
 
-            rebuilder = described_class.new(Model)
+            described_class.new(Book).rebuild
 
-            # stub respond_to? to return false since should_not_receive defines the method
-            original_respond_to = Model.method(:respond_to?)
-            allow(Model).to receive(:respond_to?) do |method_name, *args|
-              if method_name == :rebuild_pg_search_documents
-                false
-              else
-                original_respond_to.call(method_name, *args)
-              end
+            expect(pub.pg_search_document).to be_present
+            expect(draft.pg_search_document).to be_nil
+          end
+        end
+
+        context "via :unless" do
+          with_model :Book do
+            table do |t|
+              t.boolean :archived
             end
 
-            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)
+            model do
+              include PgSearch::Model
+
+              multisearchable unless: :archived?
             end
+          end
+
+          it "falls back to find_each and skips records matching the condition" do
+            live = PgSearch.disable_multisearch { Book.create!(archived: false) }
+            archived = PgSearch.disable_multisearch { Book.create!(archived: true) }
+            PgSearch::Document.delete_all
+
+            described_class.new(Book).rebuild
 
-            expect(record_1.pg_search_document).not_to be_present
-            expect(record_2.pg_search_document).to be_present
+            expect(live.pg_search_document).to be_present
+            expect(archived.pg_search_document).to be_nil
           end
-          # standard:enable RSpec/ExampleLength
         end
       end
     end

data/spec/lib/pg_search/multisearch_spec.rb

@@ -146,15 +146,14 @@ describe PgSearch::Multisearch do
 
         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)
+            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, '')
-                     ) AS content,
-                     #{connection.quote(connection.quoted_date(now))} AS created_at,
-                     #{connection.quote(connection.quoted_date(now))} AS updated_at
-              FROM #{model.quoted_table_name}
+               #{model.quoted_table_name}.#{connection.quote_column_name(model.primary_key)} AS searchable_id,
+               coalesce(cast(#{model.quoted_table_name}."title" AS text), '') AS content,
+               #{connection.quote(connection.quoted_date(now))} AS created_at,
+               #{connection.quote(connection.quoted_date(now))} AS updated_at
+               FROM #{model.quoted_table_name}
           SQL
 
           statements = []
@@ -173,15 +172,16 @@ describe PgSearch::Multisearch do
 
         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)
+            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, '')
-                     ) AS content,
-                     #{connection.quote(connection.quoted_date(now))} AS created_at,
-                     #{connection.quote(connection.quoted_date(now))} AS updated_at
-              FROM #{model.quoted_table_name}
+               #{model.quoted_table_name}.#{connection.quote_column_name(model.primary_key)} AS searchable_id,
+               coalesce(cast(#{model.quoted_table_name}."title" AS text), '') ||
+               ' ' ||
+               coalesce(cast(#{model.quoted_table_name}."content" AS text), '') AS content,
+               #{connection.quote(connection.quoted_date(now))} AS created_at,
+               #{connection.quote(connection.quoted_date(now))} AS updated_at
+               FROM #{model.quoted_table_name}
           SQL
 
           statements = []