skalee-thinking-sphinx 1.3.14.1

data/spec/fixtures/models.rb

@@ -0,0 +1,145 @@
+class Tag < ActiveRecord::Base
+  belongs_to :person
+  belongs_to :football_team
+  belongs_to :cricket_team
+end
+
+class FootballTeam < ActiveRecord::Base
+  has_many :tags
+end
+
+class CricketTeam < ActiveRecord::Base
+  define_index do
+    indexes :name
+    has "SELECT cricket_team_id, id FROM tags", :source => :query, :as => :tags
+  end
+end
+
+class Contact < ActiveRecord::Base
+  belongs_to :person
+end
+
+class Friendship < ActiveRecord::Base
+  belongs_to :person
+  belongs_to :friend, :class_name => "Person", :foreign_key => :friend_id
+  
+  define_index do
+    indexes "'something'", :as => :something
+    has person_id, friend_id
+    
+    set_property :latitude_attr   => :person_id
+    set_property :longitude_attr  => :person_id
+  end
+end
+
+class Link < ActiveRecord::Base
+  has_and_belongs_to_many :people
+end
+
+class Person < ActiveRecord::Base
+  belongs_to :team, :polymorphic => :true
+  has_many :contacts
+  
+  has_many :friendships
+  has_many :friends, :through => :friendships
+  
+  has_many :tags
+  has_many :football_teams, :through => :tags
+  
+  has_and_belongs_to_many :links
+  
+  define_index do
+    indexes [first_name, middle_initial, last_name], :as => :name
+    indexes team.name, :as => :team_name
+    indexes contacts.phone_number, :as => :phone_numbers
+    indexes city,   :prefixes => true, :facet => true
+    indexes state,  :infixes  => true, :facet => true
+    
+    has [first_name, middle_initial, last_name], :as => :name_sort
+    has team.name, :as => :team_name_sort
+    
+    has [:id, :team_id], :as => :ids
+    has team(:id), :as => :team_id
+    
+    has contacts.phone_number, :as => :phone_number_sort
+    has contacts(:id), :as => :contact_ids
+    
+    has birthday, :facet => true
+    
+    has friendships.person_id, :as => :friendly_ids
+    
+    has :id, :as => :latitude
+    has :id, :as => :longitude
+    
+    set_property :delta => true
+  end
+end
+
+class Parent < Person
+end
+
+module Admin
+  class Person < ::Person
+  end
+end
+
+class Child < Person
+  belongs_to :parent
+  define_index do
+    indexes [parent.first_name, parent.middle_initial, parent.last_name], :as => :parent_name
+  end
+end
+
+class Alpha < ActiveRecord::Base
+  has_many :betas
+  
+  define_index do
+    indexes :name, :sortable => true
+    
+    has :id, :as => :lat
+    has :id, :as => :lng
+    
+    set_property :field_weights => {"name" => 10}
+  end
+  
+  def big_name
+    name.upcase
+  end
+  
+  def string_to_escape
+    'test "escaping" <characters>'
+  end
+  
+  def sphinx_attributes
+    :existing
+  end
+end
+
+class Beta < ActiveRecord::Base
+  has_many :gammas
+  
+  define_index do
+    indexes :name, :sortable => true
+    
+    has :id, :as => :lat
+    has :id, :as => :lon
+    
+    set_property :delta => true
+  end
+  
+  def excerpts
+    false
+  end
+  
+  def matching_fields
+    :foo
+  end
+end
+
+class Gamma < ActiveRecord::Base
+  #
+end
+
+class Search < ActiveRecord::Base
+  #
+end

data/spec/fixtures/structure.sql

@@ -0,0 +1,125 @@
+DROP TABLE IF EXISTS `people`;
+
+CREATE TABLE `people` (
+  `id` int(11) NOT NULL auto_increment,
+  `first_name` varchar(50) NULL,
+  `middle_initial` varchar(10) NULL,
+  `last_name` varchar(50) NULL,
+  `gender` varchar(10) NULL,
+  `street_address` varchar(200) NULL,
+  `city` varchar(100) NULL,
+  `state` varchar(100) NULL,
+  `postcode` varchar(10) NULL,
+  `email` varchar(100) NULL,
+  `birthday` datetime NULL,
+  `team_id` int(11) NULL,
+  `team_type` varchar(50) NULL,
+  `type` varchar(50) NULL,
+  `parent_id` varchar(50) NULL,
+  `delta` tinyint(1) NOT NULL DEFAULT 0,
+  PRIMARY KEY  (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+DROP TABLE IF EXISTS `friendships`;
+
+CREATE TABLE `friendships` (
+  `id` int(11) NOT NULL auto_increment,
+  `person_id` int(11) NOT NULL,
+  `friend_id` int(11) NOT NULL,
+  `created_at` datetime NOT NULL,
+  `created_on` date NULL,
+  `updated_at` datetime NOT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+DROP TABLE IF EXISTS `football_teams`;
+
+CREATE TABLE `football_teams` (
+  `id` int(11) NOT NULL auto_increment,
+  `name` varchar(50) NOT NULL,
+  `state` varchar(50) NOT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+DROP TABLE IF EXISTS `cricket_teams`;
+
+CREATE TABLE `cricket_teams` (
+  `id` int(11) NOT NULL auto_increment,
+  `name` varchar(50) NOT NULL,
+  `state` varchar(50) NOT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+DROP TABLE IF EXISTS `contacts`;
+
+CREATE TABLE `contacts` (
+  `id` int(11) NOT NULL auto_increment,
+  `phone_number` varchar(50) NOT NULL,
+  `person_id` int(11) NOT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+DROP TABLE IF EXISTS `alphas`;
+
+CREATE TABLE `alphas` (
+  `id` int(11) NOT NULL auto_increment,
+  `name` varchar(50) NOT NULL,
+  `value` int(11),
+  `cost` decimal(10,6),
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+DROP TABLE IF EXISTS `betas`;
+
+CREATE TABLE `betas` (
+  `id` int(11) NOT NULL auto_increment,
+  `name` varchar(50) NOT NULL,
+  `alpha_id` int(11),
+  `delta` tinyint(1) NOT NULL DEFAULT 0,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+DROP TABLE IF EXISTS `gammas`;
+
+CREATE TABLE `gammas` (
+  `id` int(11) NOT NULL auto_increment,
+  `name` varchar(50) NOT NULL,
+  `value` int(11),
+  `beta_id` int(11),
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+DROP TABLE IF EXISTS `searches`;
+
+CREATE TABLE `searches` (
+  `id` int(11) NOT NULL auto_increment,
+  `name` varchar(50) NOT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+DROP TABLE IF EXISTS `tags`;
+
+CREATE TABLE `tags` (
+  `id` int(11) NOT NULL auto_increment,
+  `person_id` int(11) NOT NULL,
+  `football_team_id` int(11) NOT NULL,
+  `cricket_team_id` int(11) NOT NULL,
+  `name` varchar(50) NOT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+DROP TABLE IF EXISTS `links`;
+
+CREATE TABLE `links` (
+  `id` int(11) NOT NULL auto_increment,
+  `url` varchar(50) NOT NULL,
+  `description` varchar(200),
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+DROP TABLE IF EXISTS `links_people`;
+
+CREATE TABLE `links_people` (
+  `link_id` int(11) NOT NULL,
+  `person_id` int(11) NOT NULL
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;

data/spec/spec_helper.rb

@@ -0,0 +1,60 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+Dir[File.join(File.dirname(__FILE__), '../vendor/*/lib')].each do |path|
+  $:.unshift path
+end
+
+require 'rubygems'
+require 'fileutils'
+require 'ginger'
+require 'jeweler'
+
+require "lib/thinking_sphinx"
+
+require 'will_paginate'
+
+require 'spec/sphinx_helper'
+
+ActiveRecord::Base.logger = Logger.new(StringIO.new)
+
+Spec::Runner.configure do |config|
+  %w( tmp tmp/config tmp/log tmp/db ).each do |path|
+    FileUtils.mkdir_p "#{Dir.pwd}/#{path}"
+  end
+  
+  Kernel.const_set :RAILS_ROOT, "#{Dir.pwd}/tmp" unless defined?(RAILS_ROOT)
+  
+  sphinx = SphinxHelper.new
+  sphinx.setup_mysql
+  
+  require 'spec/fixtures/models'
+  ThinkingSphinx.context.define_indexes
+  
+  config.before :all do
+    %w( tmp tmp/config tmp/log tmp/db ).each do |path|
+      FileUtils.mkdir_p "#{Dir.pwd}/#{path}"
+    end
+    
+    ThinkingSphinx.updates_enabled = true
+    ThinkingSphinx.deltas_enabled = true
+    ThinkingSphinx.suppress_delta_output = true
+    
+    ThinkingSphinx::Configuration.instance.reset
+    ThinkingSphinx::Configuration.instance.database_yml_file = "spec/fixtures/sphinx/database.yml"
+  end
+  
+  config.after :all do
+    FileUtils.rm_r "#{Dir.pwd}/tmp" rescue nil
+  end
+end
+
+def minimal_result_hashes(*instances)
+  instances.collect do |instance|
+    {
+      :weight     => 21,
+      :attributes => {
+        'sphinx_internal_id' => instance.id,
+        'class_crc'          => instance.class.name.to_crc32
+      }
+    }
+  end
+end

data/spec/sphinx_helper.rb

@@ -0,0 +1,81 @@
+require 'active_record'
+prefix = defined?(JRUBY_VERSION) ? "jdbc" : ""
+require "active_record/connection_adapters/#{prefix}mysql_adapter"
+begin
+  require "active_record/connection_adapters/#{prefix}postgresql_adapter"
+rescue LoadError
+  # No postgres?  no prob...
+end
+require 'yaml'
+
+class SphinxHelper
+  attr_accessor :host, :username, :password, :socket
+  attr_reader   :path
+
+  def initialize
+    @host     = "localhost"
+    @username = "thinking_sphinx"
+    @password = ""
+
+    if File.exist?("spec/fixtures/database.yml")
+      config    = YAML.load(File.open("spec/fixtures/database.yml"))
+      @host     = config["host"]
+      @username = config["username"]
+      @password = config["password"]
+      @socket   = config["socket"]
+    end
+
+    @path = File.expand_path(File.dirname(__FILE__))
+  end
+
+  def mysql_adapter
+    defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql'
+  end
+
+  def setup_mysql
+    ActiveRecord::Base.establish_connection(
+      :adapter  => mysql_adapter,
+      :database => 'thinking_sphinx',
+      :username => @username,
+      :password => @password,
+      :host     => @host,
+      :socket   => @socket
+    )
+    ActiveRecord::Base.logger = Logger.new(File.open("tmp/activerecord.log", "a"))
+
+    structure = File.open("spec/fixtures/structure.sql") { |f| f.read.chomp }
+    structure.split(';').each { |table|
+      ActiveRecord::Base.connection.execute table
+    }
+
+    File.open("spec/fixtures/data.sql") { |f|
+      while line = f.gets
+        ActiveRecord::Base.connection.execute line unless line.blank?
+      end
+    }
+  end
+
+  def setup_sphinx
+    @configuration = ThinkingSphinx::Configuration.instance.reset
+    File.open("spec/fixtures/sphinx/database.yml", "w") do |file|
+      YAML.dump({@configuration.environment => {
+        :adapter  => mysql_adapter,
+        :host     => @host,
+        :database => "thinking_sphinx",
+        :username => @username,
+        :password => @password
+      }}, file)
+    end
+    FileUtils.mkdir_p(@configuration.searchd_file_path)
+
+    @configuration.database_yml_file = "spec/fixtures/sphinx/database.yml"
+    @configuration.build
+
+    index
+  end
+
+  def reset
+    setup_mysql
+  end
+
+end

data/spec/thinking_sphinx/active_record/delta_spec.rb

@@ -0,0 +1,128 @@
+require 'spec/spec_helper'
+
+describe "ThinkingSphinx::ActiveRecord::Delta" do
+  it "should call the toggle_delta method after a save" do
+    @beta = Beta.new(:name => 'beta')
+    @beta.should_receive(:toggle_delta).and_return(true)
+    
+    @beta.save
+  end
+  
+  it "should call the toggle_delta method after a save!" do
+    @beta = Beta.new(:name => 'beta')
+    @beta.should_receive(:toggle_delta).and_return(true)
+    
+    @beta.save!
+  end
+  
+  describe "suspended_delta method" do
+    before :each do
+      ThinkingSphinx.deltas_enabled = true
+      Person.sphinx_indexes.first.delta_object.stub!(:` => "")
+    end
+
+    it "should execute the argument block with deltas disabled" do
+      ThinkingSphinx.should_receive(:deltas_enabled=).once.with(false)
+      ThinkingSphinx.should_receive(:deltas_enabled=).once.with(true)
+      lambda { Person.suspended_delta { raise 'i was called' } }.should(
+        raise_error(Exception)
+      )
+    end
+
+    it "should restore deltas_enabled to its original setting" do
+      ThinkingSphinx.deltas_enabled = false
+      ThinkingSphinx.should_receive(:deltas_enabled=).twice.with(false)
+      Person.suspended_delta { 'no-op' }
+    end
+
+    it "should restore deltas_enabled to its original setting even if there was an exception" do
+      ThinkingSphinx.deltas_enabled = false
+      ThinkingSphinx.should_receive(:deltas_enabled=).twice.with(false)
+      lambda { Person.suspended_delta { raise 'bad error' } }.should(
+        raise_error(Exception)
+      )
+    end
+
+    it "should reindex by default after the code block is run" do
+      Person.should_receive(:index_delta)
+      Person.suspended_delta { 'no-op' }
+    end
+    
+    it "should not reindex after the code block if false is passed in" do
+      Person.should_not_receive(:index_delta)
+      Person.suspended_delta(false) { 'no-op' }
+    end
+  end
+  
+  describe "toggle_delta method" do
+    it "should set the delta value to true" do
+      @person = Person.new
+      
+      @person.delta.should be_false
+      @person.send(:toggle_delta)
+      @person.delta.should be_true
+    end
+  end
+  
+  describe "index_delta method" do
+    before :each do
+      ThinkingSphinx::Configuration.stub!(:environment => "spec")
+      ThinkingSphinx.deltas_enabled   = true
+      ThinkingSphinx.updates_enabled  = true
+      ThinkingSphinx.stub!(:sphinx_running? => true)
+      Person.delta_object.stub!(:` => "", :toggled => true)
+      
+      @person = Person.new
+      Person.stub!(:search_for_id => false)
+      @person.stub!(:sphinx_document_id => 1)
+      
+      @client = Riddle::Client.new
+      @client.stub!(:update => true)
+      ThinkingSphinx::Configuration.instance.stub!(:client => @client)
+    end
+    
+    it "shouldn't index if delta indexing is disabled" do
+      ThinkingSphinx.deltas_enabled = false
+      Person.sphinx_indexes.first.delta_object.should_not_receive(:`)
+      @client.should_not_receive(:update)
+      
+      @person.send(:index_delta)
+    end
+    
+    it "shouldn't index if index updating is disabled" do
+      ThinkingSphinx.updates_enabled = false
+      Person.sphinx_indexes.first.delta_object.should_not_receive(:`)
+      
+      @person.send(:index_delta)
+    end
+    
+    it "shouldn't index if the environment is 'test'" do
+      ThinkingSphinx.deltas_enabled = nil
+      ThinkingSphinx::Configuration.stub!(:environment => "test")
+      Person.sphinx_indexes.first.delta_object.should_not_receive(:`)
+      
+      @person.send(:index_delta)
+    end
+    
+    it "should call indexer for the delta index" do
+      Person.sphinx_indexes.first.delta_object.should_receive(:`).with(
+        "#{ThinkingSphinx::Configuration.instance.bin_path}indexer --config #{ThinkingSphinx::Configuration.instance.config_file} --rotate person_delta"
+      )
+      
+      @person.send(:index_delta)
+    end
+    
+    it "shouldn't update the deleted attribute if not in the index" do
+      @client.should_not_receive(:update)
+      
+      @person.send(:index_delta)
+    end
+    
+    it "should update the deleted attribute if in the core index" do
+      Person.stub!(:search_for_id => true)
+      @client.should_receive(:update)
+      
+      @person.send(:index_delta)
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/has_many_association_spec.rb

@@ -0,0 +1,55 @@
+require 'spec/spec_helper'
+
+describe 'ThinkingSphinx::ActiveRecord::HasManyAssociation' do
+  describe "search method" do
+    before :each do
+      Friendship.stub!(:search => true)
+      
+      @person = Person.find(:first)
+      @index  = Friendship.sphinx_indexes.first
+    end
+    
+    it "should raise an error if the required attribute doesn't exist" do
+      @index.stub!(:attributes => [])
+      
+      lambda { @person.friendships.search "test" }.should raise_error(RuntimeError)
+    end
+    
+    it "should add a filter for the attribute into a normal search call" do
+      Friendship.should_receive(:search) do |query, options|
+        options[:with][:person_id].should == @person.id
+      end
+      
+      @person.friendships.search "test"
+    end
+    
+    it "should define indexes for the reflection class" do
+      Friendship.should_receive(:define_indexes)
+      
+      @person.friendships.search 'test'
+    end
+  end
+  
+  describe "search method for has_many :through" do
+    before :each do
+      Person.stub!(:search => true)
+      
+      @person = Person.find(:first)
+      @index  = Person.sphinx_indexes.first
+    end
+    
+    it "should raise an error if the required attribute doesn't exist" do
+      @index.stub!(:attributes => [])
+      
+      lambda { @person.friends.search "test" }.should raise_error(RuntimeError)
+    end
+    
+    it "should add a filter for the attribute into a normal search call" do
+      Person.should_receive(:search).with do |query, options|
+        options[:with][:friendly_ids].should == @person.id
+      end
+      
+      @person.friends.search "test"
+    end
+  end
+end