thinking-sphinx 1.2.13 → 6.0.0

data/spec/acceptance/real_time_updates_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'acceptance/spec_helper'
+
+describe 'Updates to records in real-time indices', :live => true do
+  it "handles fields with unicode nulls" do
+    product = Product.create! :name => "Widget \u0000"
+
+    expect(Product.search.first).to eq(product)
+  end unless ENV['DATABASE'] == 'postgresql'
+
+  it "handles attributes for sortable fields accordingly" do
+    product = Product.create! :name => 'Red Fish'
+    product.update :name => 'Blue Fish'
+
+    expect(Product.search('blue fish', :indices => ['product_core']).to_a).
+      to eq([product])
+  end
+
+  it "handles inserts and updates for namespaced models" do
+    person = Admin::Person.create :name => 'Death'
+
+    expect(Admin::Person.search('Death').to_a).to eq([person])
+
+    person.update :name => 'Mort'
+
+    expect(Admin::Person.search('Death').to_a).to be_empty
+    expect(Admin::Person.search('Mort').to_a).to eq([person])
+  end
+
+  it "can use direct interface for upserting records" do
+    Admin::Person.connection.execute <<~SQL
+      INSERT INTO admin_people (name, created_at, updated_at)
+      VALUES ('Pat', now(), now());
+    SQL
+
+    expect(Admin::Person.search('Pat').to_a).to be_empty
+
+    instance = Admin::Person.find_by(:name => 'Pat')
+    ThinkingSphinx::Processor.new(instance: instance).upsert
+
+    expect(Admin::Person.search('Pat').to_a).to eq([instance])
+
+    Admin::Person.connection.execute <<~SQL
+      UPDATE admin_people SET name = 'Patrick' WHERE name = 'Pat';
+    SQL
+
+    expect(Admin::Person.search('Patrick').to_a).to be_empty
+
+    instance.reload
+    ThinkingSphinx::Processor.new(model: Admin::Person, id: instance.id).upsert
+
+    expect(Admin::Person.search('Patrick').to_a).to eq([instance])
+  end
+
+  it "can use direct interface for processing records outside scope" do
+    Article.connection.execute <<~SQL
+      INSERT INTO articles (title, published, created_at, updated_at)
+      VALUES ('Nice Title', TRUE, now(), now());
+    SQL
+
+    article  = Article.last
+
+    ThinkingSphinx::Processor.new(model: article.class, id: article.id).sync
+
+    expect(ThinkingSphinx.search('Nice', :indices => ["published_articles_core"])).to include(article)
+
+    Article.connection.execute <<~SQL
+      UPDATE articles SET published = FALSE WHERE title = 'Nice Title';
+    SQL
+    ThinkingSphinx::Processor.new(model: article.class, id: article.id).sync
+
+    expect(ThinkingSphinx.search('Nice', :indices => ["published_articles_core"])).to be_empty
+  end
+
+  it "can use direct interface for processing deleted records" do
+    Article.connection.execute <<~SQL
+      INSERT INTO articles (title, published, created_at, updated_at)
+      VALUES ('Nice Title', TRUE, now(), now());
+    SQL
+
+    article  = Article.last
+    ThinkingSphinx::Processor.new(:instance => article).sync
+
+    expect(ThinkingSphinx.search('Nice', :indices => ["published_articles_core"])).to include(article)
+
+    Article.connection.execute <<~SQL
+      DELETE FROM articles where title = 'Nice Title';
+    SQL
+
+    ThinkingSphinx::Processor.new(:instance => article).sync
+
+    expect(ThinkingSphinx.search('Nice', :indices => ["published_articles_core"])).to be_empty
+  end
+
+  it "syncs records in real-time index with alternate ids" do
+    Album.connection.execute <<~SQL
+      INSERT INTO albums (id, name, artist, integer_id)
+      VALUES ('#{("a".."z").to_a.sample}', 'Sing to the Moon', 'Laura Mvula', #{rand(10000)});
+    SQL
+
+    album  = Album.last
+    ThinkingSphinx::Processor.new(:model => Album, id: album.integer_id).sync
+
+    expect(ThinkingSphinx.search('Laura', :indices => ["album_real_core"])).to include(album)
+
+    Article.connection.execute <<~SQL
+      DELETE FROM albums where id = '#{album.id}';
+    SQL
+
+    ThinkingSphinx::Processor.new(:instance => album).sync
+
+    expect(ThinkingSphinx.search('Laura', :indices => ["album_real_core"])).to be_empty
+  end
+end

data/spec/acceptance/remove_deleted_records_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'acceptance/spec_helper'
+
+describe 'Hiding deleted records from search results', :live => true do
+  it "does not return deleted records" do
+    pancakes = Article.create! :title => 'Pancakes'
+    index
+
+    expect(Article.search('pancakes')).not_to be_empty
+    pancakes.destroy
+
+    expect(Article.search('pancakes')).to be_empty
+  end
+
+  it "will catch stale records deleted without callbacks being fired" do
+    pancakes = Article.create! :title => 'Pancakes'
+    index
+
+    expect(Article.search('pancakes')).not_to be_empty
+    Article.connection.execute "DELETE FROM articles WHERE id = #{pancakes.id}"
+
+    expect(Article.search('pancakes')).to be_empty
+  end
+
+  it "removes records from real-time index results" do
+    product = Product.create! :name => 'Shiny'
+
+    expect(Product.search('Shiny', :indices => ['product_core']).to_a).
+      to eq([product])
+
+    product.destroy
+
+    expect(Product.search_for_ids('Shiny', :indices => ['product_core'])).
+      to be_empty
+  end
+
+  it "removes records from real-time index results with alternate ids" do
+    album = Album.create! :name => 'Sing to the Moon', :artist => 'Laura Mvula'
+
+    expect(Album.search('Sing', :indices => ['album_real_core']).to_a).
+      to eq([album])
+
+    album.destroy
+
+    expect(Album.search_for_ids('Sing', :indices => ['album_real_core'])).
+      to be_empty
+  end
+
+  it "does not remove real-time results when callbacks are disabled" do
+    original = ThinkingSphinx::Configuration.instance.
+      settings['real_time_callbacks']
+    product = Product.create! :name => 'Shiny'
+    expect(Product.search('Shiny', :indices => ['product_core']).to_a).
+      to eq([product])
+
+    ThinkingSphinx::Configuration.instance.
+      settings['real_time_callbacks'] = false
+
+    product.destroy
+    expect(Product.search_for_ids('Shiny', :indices => ['product_core'])).
+      not_to be_empty
+
+    ThinkingSphinx::Configuration.instance.
+      settings['real_time_callbacks'] = original
+  end
+
+  it "deletes STI child classes from parent indices" do
+    duck = Bird.create :name => 'Duck'
+    index
+    duck.destroy
+
+    expect(Bird.search_for_ids('duck')).to be_empty
+  end
+
+  it "can use a direct interface for processing records" do
+    pancakes = Article.create! :title => 'Pancakes'
+    index
+    expect(Article.search('pancakes')).not_to be_empty
+
+    Article.connection.execute "DELETE FROM articles WHERE id = #{pancakes.id}"
+    expect(Article.search_for_ids('pancakes')).not_to be_empty
+
+    ThinkingSphinx::Processor.new(instance: pancakes).delete
+    expect(Article.search_for_ids('pancakes')).to be_empty
+  end
+
+  it "can use a direct interface for processing records without an instance" do
+    pancakes = Article.create! :title => 'Pancakes'
+    index
+    expect(Article.search('pancakes')).not_to be_empty
+
+    Article.connection.execute "DELETE FROM articles WHERE id = #{pancakes.id}"
+    expect(Article.search_for_ids('pancakes')).not_to be_empty
+
+    ThinkingSphinx::Processor.new(model: Article, id: pancakes.id).delete
+    expect(Article.search_for_ids('pancakes')).to be_empty
+  end
+end

data/spec/acceptance/search_counts_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'acceptance/spec_helper'
+
+describe 'Get search result counts', :live => true do
+  it "returns counts for a single model" do
+    4.times { |i| Article.create :title => "Article #{i}" }
+    index
+
+    expect(Article.search_count).to eq(4)
+  end
+
+  it "returns counts across all models" do
+    3.times { |i| Article.create :title => "Article #{i}" }
+    2.times { |i| Book.create :title => "Book #{i}" }
+    index
+
+    expect(ThinkingSphinx.count).to eq(5)
+  end
+end

data/spec/acceptance/search_for_just_ids_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'acceptance/spec_helper'
+
+describe 'Searching for just instance Ids', :live => true do
+  it "returns just the instance ids" do
+    pancakes = Article.create! :title => 'Pancakes'
+    waffles  = Article.create! :title => 'Waffles'
+    index
+
+    expect(Article.search_for_ids('pancakes').to_a).to eq([pancakes.id])
+  end
+
+  it "works across the global context" do
+    article = Article.create! :title => 'Pancakes'
+    book    = Book.create! :title => 'American Gods'
+    index
+
+    expect(ThinkingSphinx.search_for_ids.to_a).to match_array([article.id, book.id])
+  end
+end

data/spec/acceptance/searching_across_models_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'acceptance/spec_helper'
+
+describe 'Searching across models', :live => true do
+  it "returns results" do
+    article = Article.create! :title => 'Pancakes'
+    index
+
+    expect(ThinkingSphinx.search.first).to eq(article)
+  end
+
+  it "returns results matching the given query" do
+    pancakes = Article.create! :title => 'Pancakes'
+    waffles  = Article.create! :title => 'Waffles'
+    index
+
+    articles = ThinkingSphinx.search 'pancakes'
+    expect(articles).to include(pancakes)
+    expect(articles).not_to include(waffles)
+  end
+
+  it "handles results from different models" do
+    article = Article.create! :title => 'Pancakes'
+    book    = Book.create! :title => 'American Gods'
+    index
+
+    expect(ThinkingSphinx.search.to_a).to match_array([article, book])
+  end
+
+  it "filters by multiple classes" do
+    article = Article.create! :title => 'Pancakes'
+    book    = Book.create! :title => 'American Gods'
+    user    = User.create! :name => 'Pat'
+    index
+
+    expect(ThinkingSphinx.search(:classes => [User, Article]).to_a).
+      to match_array([article, user])
+  end
+
+  it "has a 'none' default scope" do
+    article = Article.create! :title => 'Pancakes'
+    index
+
+    expect(ThinkingSphinx.none).to be_empty
+  end
+end

data/spec/acceptance/searching_across_schemas_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'acceptance/spec_helper'
+
+multi_schema = MultiSchema.new
+
+describe 'Searching across PostgreSQL schemas', :live => true do
+  before :each do
+    ThinkingSphinx::Configuration.instance.index_set_class =
+      MultiSchema::IndexSet
+  end
+
+  after :each do
+    ThinkingSphinx::Configuration.instance.index_set_class = nil
+    multi_schema.switch :public
+  end
+
+  it 'can distinguish between objects with the same primary key' do
+    multi_schema.switch :public
+    jekyll = Product.create name: 'Doctor Jekyll'
+    expect(Product.search('Jekyll', :retry_stale => false).to_a).to eq([jekyll])
+    expect(Product.search(:retry_stale => false).to_a).to eq([jekyll])
+
+    multi_schema.switch :thinking_sphinx
+    hyde = Product.create name: 'Mister Hyde'
+    expect(Product.search('Jekyll', :retry_stale => false).to_a).to eq([])
+    expect(Product.search('Hyde', :retry_stale => false).to_a).to eq([hyde])
+    expect(Product.search(:retry_stale => false).to_a).to eq([hyde])
+
+    multi_schema.switch :public
+    expect(Product.search('Jekyll', :retry_stale => false).to_a).to eq([jekyll])
+    expect(Product.search(:retry_stale => false).to_a).to eq([jekyll])
+    expect(Product.search('Hyde', :retry_stale => false).to_a).to eq([])
+
+    expect(Product.search(
+      :middleware => ThinkingSphinx::Middlewares::RAW_ONLY,
+      :indices    => ['product_core', 'product_two_core']
+    ).to_a.length).to eq(2)
+  end
+end if multi_schema.active?

data/spec/acceptance/searching_on_fields_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'acceptance/spec_helper'
+
+describe 'Searching on fields', :live => true do
+  it "limits results by field" do
+    pancakes = Article.create! :title => 'Pancakes'
+    waffles  = Article.create! :title => 'Waffles',
+      :content => 'Different to pancakes - and not quite as tasty.'
+    index
+
+    articles = Article.search :conditions => {:title => 'pancakes'}
+    expect(articles).to include(pancakes)
+    expect(articles).not_to include(waffles)
+  end
+
+  it "limits results for a field from an association" do
+    user     = User.create! :name => 'Pat'
+    pancakes = Article.create! :title => 'Pancakes', :user => user
+    index
+
+    expect(Article.search(:conditions => {:user => 'pat'}).first).to eq(pancakes)
+  end
+
+  it "returns results with matches from grouped fields" do
+    user     = User.create! :name => 'Pat'
+    pancakes = Article.create! :title => 'Pancakes', :user => user
+    waffles  = Article.create! :title => 'Waffles',  :user => user
+    index
+
+    expect(Article.search('waffles', :conditions => {:title => 'pancakes'}).to_a).
+      to eq([pancakes])
+  end
+
+  it "returns results with matches from concatenated columns in a field" do
+    book = Book.create! :title => 'Night Watch', :author => 'Terry Pratchett'
+    index
+
+    expect(Book.search(:conditions => {:info => 'Night Pratchett'}).to_a).
+      to eq([book])
+  end
+
+  it "handles NULLs in concatenated fields" do
+    book = Book.create! :title => 'Night Watch'
+    index
+
+    expect(Book.search(:conditions => {:info => 'Night Watch'}).to_a).to eq([book])
+  end
+
+  it "returns results with matches from file fields" do
+    file_path = Rails.root.join('tmp', 'caption.txt')
+    File.open(file_path, 'w') { |file| file.print 'Cyberpunk at its best' }
+
+    book = Book.create! :title => 'Accelerando', :blurb_file => file_path.to_s
+    index
+
+    expect(Book.search('cyberpunk').to_a).to eq([book])
+  end
+end

data/spec/acceptance/searching_with_filters_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'acceptance/spec_helper'
+
+describe 'Searching with filters', :live => true do
+  it "limits results by single value boolean filters" do
+    pancakes = Article.create! :title => 'Pancakes', :published => true
+    waffles  = Article.create! :title => 'Waffles',  :published => false
+    index
+
+    expect(Article.search(:with => {:published => true}).to_a).to eq([pancakes])
+  end
+
+  it "limits results by an array of values" do
+    gods  = Book.create! :title => 'American Gods',      :publishing_year => 2001
+    boys  = Book.create! :title => 'Anansi Boys',        :publishing_year => 2005
+    grave = Book.create! :title => 'The Graveyard Book', :publishing_year => 2009
+    index
+
+    expect(Book.search(:with => {:publishing_year => [2001, 2005]}).to_a).to match_array([gods, boys])
+  end
+
+  it "limits results by a ranged filter" do
+    gods  = Book.create! :title => 'American Gods'
+    boys  = Book.create! :title => 'Anansi Boys'
+    grave = Book.create! :title => 'The Graveyard Book'
+
+    gods.update_column  :created_at, 5.days.ago
+    boys.update_column  :created_at, 3.days.ago
+    grave.update_column :created_at, 1.day.ago
+    index
+
+    expect(Book.search(:with => {:created_at => 6.days.ago..2.days.ago}).to_a).
+      to match_array([gods, boys])
+  end
+
+  it "limits results by exclusive filters on single values" do
+    pancakes = Article.create! :title => 'Pancakes', :published => true
+    waffles  = Article.create! :title => 'Waffles',  :published => false
+    index
+
+    expect(Article.search(:without => {:published => true}).to_a).to eq([waffles])
+  end
+
+  it "limits results by exclusive filters on arrays of values" do
+    gods  = Book.create! :title => 'American Gods',      :publishing_year => 2001
+    boys  = Book.create! :title => 'Anansi Boys',        :publishing_year => 2005
+    grave = Book.create! :title => 'The Graveyard Book', :publishing_year => 2009
+    index
+
+    expect(Book.search(:without => {:publishing_year => [2001, 2005]}).to_a).to eq([grave])
+  end
+
+  it "limits results by ranged filters on timestamp MVAs" do
+    pancakes = Article.create :title => 'Pancakes'
+    waffles  = Article.create :title => 'Waffles'
+
+    food = Tag.create :name => 'food'
+    flat = Tag.create :name => 'flat'
+
+    Tagging.create(:tag => food, :article => pancakes).
+      update_column :created_at, 5.days.ago
+    Tagging.create :tag => flat, :article => pancakes
+    Tagging.create(:tag => food, :article => waffles).
+      update_column :created_at, 3.days.ago
+
+    index
+
+    expect(Article.search(
+      :with => {:taggings_at => 1.days.ago..1.day.from_now}
+    ).to_a).to eq([pancakes])
+  end
+
+  it "takes into account local timezones for timestamps" do
+    pancakes = Article.create :title => 'Pancakes'
+    waffles  = Article.create :title => 'Waffles'
+
+    food = Tag.create :name => 'food'
+    flat = Tag.create :name => 'flat'
+
+    Tagging.create(:tag => food, :article => pancakes).
+      update_column :created_at, 5.minutes.ago
+    Tagging.create :tag => flat, :article => pancakes
+    Tagging.create(:tag => food, :article => waffles).
+      update_column :created_at, 3.minute.ago
+
+    index
+
+    expect(Article.search(
+      :with => {:taggings_at => 2.minutes.ago..Time.zone.now}
+    ).to_a).to eq([pancakes])
+  end
+
+  it "limits results with MVAs having all of the given values" do
+    pancakes = Article.create :title => 'Pancakes'
+    waffles  = Article.create :title => 'Waffles'
+
+    food = Tag.create :name => 'food'
+    flat = Tag.create :name => 'flat'
+
+    Tagging.create :tag => food, :article => pancakes
+    Tagging.create :tag => flat, :article => pancakes
+    Tagging.create :tag => food, :article => waffles
+
+    index
+
+    articles = Article.search :with_all => {:tag_ids => [food.id, flat.id]}
+    expect(articles.to_a).to eq([pancakes])
+  end
+
+  it "limits results with MVAs that don't contain all the given values" do
+    # Matching results may have some of the given values, but cannot have all
+    # of them. Certainly an edge case.
+    skip "SphinxQL doesn't yet support OR in its WHERE clause"
+
+    pancakes = Article.create :title => 'Pancakes'
+    waffles  = Article.create :title => 'Waffles'
+
+    food = Tag.create :name => 'food'
+    flat = Tag.create :name => 'flat'
+
+    Tagging.create :tag => food, :article => pancakes
+    Tagging.create :tag => flat, :article => pancakes
+    Tagging.create :tag => food, :article => waffles
+
+    index
+
+    articles = Article.search :without_all => {:tag_ids => [food.id, flat.id]}
+    expect(articles.to_a).to eq([waffles])
+  end
+
+  it "limits results on real-time indices with multi-value integer attributes" do
+    pancakes = Product.create :name => 'Pancakes'
+    waffles  = Product.create :name => 'Waffles'
+
+    food = Category.create :name => 'food'
+    flat = Category.create :name => 'flat'
+
+    pancakes.categories << food
+    pancakes.categories << flat
+    waffles.categories  << food
+
+    products = Product.search :with => {:category_ids => [flat.id]}
+    expect(products.to_a).to eq([pancakes])
+  end
+
+  it 'searches with real-time JSON attributes' do
+    pancakes = Product.create :name => 'Pancakes',
+      :options => {'lemon' => 1, 'sugar' => 1, :number => 3}
+    waffles  = Product.create :name => 'Waffles',
+      :options => {'chocolate' => 1, 'sugar' => 1, :number => 1}
+
+    products = Product.search :with => {"options.lemon" => 1}
+    expect(products.to_a).to eq([pancakes])
+
+    products = Product.search :with => {"options.sugar" => 1}
+    expect(products.to_a).to match_array([pancakes, waffles])
+  end if JSONColumn.call
+end

data/spec/acceptance/searching_with_sti_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'acceptance/spec_helper'
+
+describe 'Searching across STI models', :live => true do
+  it "returns super- and sub-class results" do
+    platypus = Animal.create :name => 'Platypus'
+    duck     = Bird.create :name => 'Duck'
+    index
+
+    expect(Animal.search(:indices  => ['animal_core']).to_a).to eq([platypus, duck])
+  end
+
+  it "limits results based on subclasses" do
+    platypus = Animal.create :name => 'Platypus'
+    duck     = Bird.create :name => 'Duck'
+    index
+
+    expect(Bird.search(:indices  => ['animal_core']).to_a).to eq([duck])
+  end
+
+  it "returns results for deeper subclasses when searching on their parents" do
+    platypus = Animal.create :name => 'Platypus'
+    duck     = Bird.create :name => 'Duck'
+    emu      = FlightlessBird.create :name => 'Emu'
+    index
+
+    expect(Bird.search(:indices  => ['animal_core']).to_a).to eq([duck, emu])
+  end
+
+  it "returns results for deeper subclasses" do
+    platypus = Animal.create :name => 'Platypus'
+    duck     = Bird.create :name => 'Duck'
+    emu      = FlightlessBird.create :name => 'Emu'
+    index
+
+    expect(FlightlessBird.search(:indices  => ['animal_core']).to_a).to eq([emu])
+  end
+
+  it "filters out sibling subclasses" do
+    platypus = Animal.create :name => 'Platypus'
+    duck     = Bird.create :name => 'Duck'
+    otter    = Mammal.create :name => 'Otter'
+    index
+
+    expect(Bird.search(:indices  => ['animal_core']).to_a).to eq([duck])
+  end
+
+  it "obeys :classes if supplied" do
+    platypus = Animal.create :name => 'Platypus'
+    duck     = Bird.create :name => 'Duck'
+    emu      = FlightlessBird.create :name => 'Emu'
+    index
+
+    expect(Bird.search(
+      :indices  => ['animal_core'],
+      :skip_sti => true,
+      :classes  => [Bird, FlightlessBird]
+    ).to_a).to eq([duck, emu])
+  end
+
+  it 'finds root objects when type is blank' do
+    animal = Animal.create :name => 'Animal', type: ''
+    index
+
+    expect(Animal.search(:indices => ['animal_core']).to_a).to eq([animal])
+  end
+
+  it 'allows for indices on mid-hierarchy classes' do
+    duck     = Bird.create :name => 'Duck'
+    emu      = FlightlessBird.create :name => 'Emu'
+    index
+
+    expect(Bird.search(:indices => ['bird_core']).to_a).to eq([duck, emu])
+  end
+end