riddle 2.1.0 → 2.2.0

data/spec/riddle/query_spec.rb

@@ -1,97 +0,0 @@
-require 'spec_helper'
-
-describe Riddle::Query, :live => true do
-  describe '.connection' do
-    let(:connection) { Riddle::Query.connection 'localhost', 9306 }
-
-    it "returns a MySQL Client" do
-      connection.should be_a(Mysql2::Client)
-    end
-
-    it "should handle search requests" do
-      connection.query(Riddle::Query.tables).to_a[0].should == {
-        'Index' => 'people', 'Type' => 'local'
-      }
-    end
-  end
-end unless RUBY_PLATFORM == 'java' || Riddle.loaded_version.to_i < 2
-
-describe Riddle::Query do
-  describe '.set' do
-    it 'handles a single value' do
-      Riddle::Query.set('foo', 'bar').should == 'SET GLOBAL foo = bar'
-    end
-
-    it 'handles multiple values' do
-      Riddle::Query.set('foo', [1, 2, 3]).should == 'SET GLOBAL foo = (1, 2, 3)'
-    end
-
-    it 'handles non-global settings' do
-      Riddle::Query.set('foo', 'bar', false).should == 'SET foo = bar'
-    end
-  end
-
-  describe '.snippets' do
-    it 'handles a basic request' do
-      Riddle::Query.snippets('foo bar baz', 'foo_core', 'foo').
-        should == "CALL SNIPPETS('foo bar baz', 'foo_core', 'foo')"
-    end
-
-    it 'handles a request with options' do
-      Riddle::Query.snippets('foo bar baz', 'foo_core', 'foo', :around => 5).
-        should == "CALL SNIPPETS('foo bar baz', 'foo_core', 'foo', 5 AS around)"
-    end
-
-    it 'handles string options' do
-      Riddle::Query.snippets('foo bar baz', 'foo_core', 'foo',
-        :before_match => '<strong>').should == "CALL SNIPPETS('foo bar baz', 'foo_core', 'foo', '<strong>' AS before_match)"
-    end
-
-    it "handles boolean options" do
-      Riddle::Query.snippets('foo bar baz', 'foo_core', 'foo',
-        :exact_phrase => true).should == "CALL SNIPPETS('foo bar baz', 'foo_core', 'foo', 1 AS exact_phrase)"
-    end
-
-    it "escapes quotes in the text data" do
-      Riddle::Query.snippets("foo bar 'baz", 'foo_core', 'foo').
-        should == "CALL SNIPPETS('foo bar \\'baz', 'foo_core', 'foo')"
-    end
-
-    it "escapes quotes in the query data" do
-      Riddle::Query.snippets("foo bar baz", 'foo_core', "foo'").
-        should == "CALL SNIPPETS('foo bar baz', 'foo_core', 'foo\\'')"
-    end
-  end
-
-  describe '.create_function' do
-    it 'handles a basic create request' do
-      Riddle::Query.create_function('foo', :bigint, 'foo.sh').
-        should == "CREATE FUNCTION foo RETURNS BIGINT SONAME 'foo.sh'"
-    end
-  end
-
-  describe '.update' do
-    it 'handles a basic update request' do
-      Riddle::Query.update('foo_core', 5, :deleted => 1).
-        should == 'UPDATE foo_core SET deleted = 1 WHERE id = 5'
-    end
-  end
-
-  describe '.escape' do
-    %w(( ) | - ! @ ~ / ^ $ " > < ?).each do |reserved|
-      it "escapes #{reserved}" do
-        Riddle::Query.escape(reserved).should == "\\#{reserved}"
-      end
-    end
-
-    it "escapes word-operators correctly" do
-      operators = ['MAYBE', 'NEAR', 'PARAGRAPH', 'SENTENCE', 'ZONE', 'ZONESPAN']
-      operators.each do |operator|
-        base = "string with #{operator} operator"
-        Riddle::Query.escape(base).should == base.gsub(operator, "\\#{operator}")
-      end
-
-      Riddle::Query.escape("FIND THE ZONES").should == "FIND THE ZONES"
-    end
-  end
-end

data/spec/riddle_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Riddle do
-  describe '.version_warning' do
-    before :each do
-      @existing_version = Riddle.loaded_version
-    end
-    
-    after :each do
-      Riddle.loaded_version = @existing_version
-    end
-    
-    it "should do nothing if there is a Sphinx version loaded" do
-      STDERR.should_not_receive(:puts)
-      
-      Riddle.loaded_version = '0.9.8'
-      Riddle.version_warning
-    end
-    
-    it "should output a warning if no version is loaded" do
-      STDERR.should_receive(:puts)
-      
-      Riddle.loaded_version = nil
-      Riddle.version_warning
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,34 +0,0 @@
-require 'rubygems'
-require 'bundler'
-
-$:.unshift File.dirname(__FILE__) + '/../lib'
-$:.unshift File.dirname(__FILE__) + '/..'
-
-Dir['spec/support/**/*.rb'].each { |f| require f }
-
-Bundler.require :default, :development
-
-require 'riddle'
-
-RSpec.configure do |config|
-  config.include BinaryFixtures
-
-  sphinx = Sphinx.new
-  sphinx.setup_mysql
-  sphinx.generate_configuration
-  sphinx.index
-
-  BinaryFixtures.build_fixtures Riddle.loaded_version
-
-  config.before :all do |group|
-    sphinx.start if group.class.metadata[:live]
-  end
-
-  config.after :all do |group|
-    sphinx.stop if group.class.metadata[:live]
-  end
-
-  # enable filtering for examples
-  config.filter_run :wip => true
-  config.run_all_when_everything_filtered = true
-end

data/spec/support/binary_fixtures.rb

@@ -1,18 +0,0 @@
-module BinaryFixtures
-  def self.build_fixtures(version = nil)
-    return if ENV['TRAVIS']
-
-    version ||= %w(0.9.9 1.10 2.0.1 2.1.0)
-    Array(version).each do |version|
-      FileUtils.mkdir_p "spec/fixtures/data/#{version}"
-      `php -f spec/fixtures/data_generator.#{version}.php`
-    end
-  end
-
-  def query_contents(key)
-    path     = "spec/fixtures/data/#{Riddle.loaded_version}/#{key}.bin"
-    contents = open(path) { |f| f.read }
-    contents.respond_to?(:encoding) ?
-      contents.force_encoding('ASCII-8BIT') : contents
-  end
-end

data/spec/support/sphinx.rb

@@ -1,137 +0,0 @@
-require 'erb'
-require 'yaml'
-
-if RUBY_PLATFORM == 'java'
-  require 'java'
-  require 'jdbc/mysql'
-end
-
-class Sphinx
-  attr_accessor :host, :username, :password
-
-  def initialize
-    self.host     = 'localhost'
-    self.username = 'root'
-    self.password = ''
-
-    if File.exist?('spec/fixtures/sql/conf.yml')
-      config    = YAML.load(File.open('spec/fixtures/sql/conf.yml'))
-      self.host     = config['host']
-      self.username = config['username']
-      self.password = config['password']
-    end
-  end
-
-  def setup_mysql
-    return setup_mysql_on_jruby if RUBY_PLATFORM == 'java'
-
-    client = Mysql2::Client.new(
-      :host     => host,
-      :username => username,
-      :password => password
-    )
-
-    databases = client.query('SHOW DATABASES', :as => :array).to_a.flatten
-    unless databases.include?('riddle')
-      client.query 'CREATE DATABASE riddle'
-    end
-
-    client.query 'USE riddle'
-
-    structure = File.open('spec/fixtures/sql/structure.sql') { |f| f.read }
-    structure.split(/;/).each { |sql| client.query sql }
-    client.query <<-SQL
-      LOAD DATA INFILE '#{fixtures_path}/sql/data.tsv' INTO TABLE
-      `riddle`.`people` FIELDS TERMINATED BY ',' ENCLOSED BY "'" (gender,
-      first_name, middle_initial, last_name, street_address, city, state,
-      postcode, email, birthday)
-    SQL
-
-    client.close
-  end
-
-  def setup_mysql_on_jruby
-    address = "jdbc:mysql://#{host}"
-    client = java.sql.DriverManager.getConnection(address, username, password)
-
-    set       = client.createStatement.executeQuery('SHOW DATABASES')
-    databases = []
-    databases << set.getString(1) while set.next
-
-    unless databases.include?('riddle')
-      client.createStatement.execute 'CREATE DATABASE riddle'
-    end
-
-    client.createStatement.execute 'USE riddle'
-
-    structure = File.open('spec/fixtures/sql/structure.sql') { |f| f.read }
-    structure.split(/;/).each { |sql| client.createStatement.execute sql }
-    client.createStatement.execute <<-SQL
-      LOAD DATA INFILE '#{fixtures_path}/sql/data.tsv' INTO TABLE
-      `riddle`.`people` FIELDS TERMINATED BY ',' ENCLOSED BY "'" (gender,
-      first_name, middle_initial, last_name, street_address, city, state,
-      postcode, email, birthday)
-    SQL
-  end
-
-  def generate_configuration
-    template = File.open('spec/fixtures/sphinx/configuration.erb') { |f| f.read }
-    File.open('spec/fixtures/sphinx/spec.conf', 'w') { |f|
-      f.puts ERB.new(template).result(binding)
-    }
-
-    FileUtils.mkdir_p "spec/fixtures/sphinx/binlog"
-  end
-
-  def index
-    cmd = "#{bin_path}indexer --config #{fixtures_path}/sphinx/spec.conf --all"
-    cmd << ' --rotate' if running?
-    `#{cmd}`
-  end
-
-  def start
-    return if running?
-
-    `#{bin_path}searchd --config #{fixtures_path}/sphinx/spec.conf`
-
-    sleep(1)
-
-    unless running?
-      puts 'Failed to start searchd daemon. Check fixtures/sphinx/searchd.log.'
-    end
-  end
-
-  def stop
-    return unless running?
-
-    stop_flag = '--stopwait'
-    stop_flag = '--stop' if Riddle.loaded_version.to_i < 1
-    `#{bin_path}searchd --config #{fixtures_path}/sphinx/spec.conf #{stop_flag}`
-  end
-
-  private
-
-  def pid
-    if File.exists?("#{fixtures_path}/sphinx/searchd.pid")
-      `cat #{fixtures_path}/sphinx/searchd.pid`[/\d+/]
-    else
-      nil
-    end
-  end
-
-  def running?
-    pid && `ps #{pid} | wc -l`.to_i > 1
-  end
-
-  def fixtures_path
-    File.expand_path File.join(File.dirname(__FILE__), '..', 'fixtures')
-  end
-
-  def bin_path
-    @bin_path ||= begin
-      path = (ENV['SPHINX_BIN'] || '').dup
-      path.insert -1, '/' if path.length > 0 && path[/\/$/].nil?
-      path
-    end
-  end
-end

data/spec/unit/client_spec.rb

@@ -1,290 +0,0 @@
-require 'spec_helper'
-
-describe Riddle::Client do
-  it "should have the same keys for both commands and versions, except persist" do
-    
-    (Riddle::Client::Commands.keys - [:persist]).should == Riddle::Client::Versions.keys
-  end
-  
-  it "should default to localhost as the server" do
-    Riddle::Client.new.server.should == "localhost"
-  end
-  
-  it "should default to port 9312" do
-    Riddle::Client.new.port.should == 9312
-  end
-
-  it "should accept an array of servers" do
-    servers = ["1.1.1.1", "2.2.2.2", "3.3.3.3"]
-    client = Riddle::Client.new(servers)
-    client.servers.should == servers
-  end
-  
-  it "should translate anchor arguments correctly" do
-    client = Riddle::Client.new
-    client.set_anchor "latitude", 10.0, "longitude", 95.0
-    client.anchor.should == {
-      :latitude_attribute   => "latitude",
-      :latitude             => 10.0,
-      :longitude_attribute  => "longitude",
-      :longitude            => 95.0
-    }
-  end
-  
-  it "should add queries to the queue" do
-    client = Riddle::Client.new
-    client.queue.should be_empty
-    client.append_query "spec"
-    client.queue.should_not be_empty
-  end
-  
-  describe 'query contents' do
-    it "should build a basic search message correctly" do
-      client = Riddle::Client.new
-      client.append_query "test "
-      client.queue.first.should == query_contents(:simple)
-    end
-  
-    it "should build a message with a specified index correctly" do
-      client = Riddle::Client.new
-      client.append_query "test ", "edition"
-      client.queue.first.should == query_contents(:index)
-    end
-  
-    it "should build a message using match mode :any correctly" do
-      client = Riddle::Client.new
-      client.match_mode = :any
-      client.append_query "test this "
-      client.queue.first.should == query_contents(:any)
-    end
-  
-    it "should build a message using sort by correctly" do
-      client = Riddle::Client.new
-      client.sort_by = 'id'
-      client.sort_mode = :extended
-      client.append_query "testing "
-      client.queue.first.should == query_contents(:sort)
-    end
-  
-    it "should build a message using match mode :boolean correctly" do
-      client = Riddle::Client.new
-      client.match_mode = :boolean
-      client.append_query "test "
-      client.queue.first.should == query_contents(:boolean)
-    end
-  
-    it "should build a message using match mode :phrase correctly" do
-      client = Riddle::Client.new
-      client.match_mode = :phrase
-      client.append_query "testing this "
-      client.queue.first.should == query_contents(:phrase)
-    end
-  
-    it "should build a message with a filter correctly" do
-      client = Riddle::Client.new
-      client.filters << Riddle::Client::Filter.new("id", [10, 100, 1000])
-      client.append_query "test "
-      client.queue.first.should == query_contents(:filter)
-    end
-  
-    it "should build a message with group values correctly" do
-      client = Riddle::Client.new
-      client.group_by       = "id"
-      client.group_function = :attr
-      client.group_clause   = "id"
-      client.append_query "test "
-      client.queue.first.should == query_contents(:group)
-    end
-  
-    it "should build a message with group distinct value correctly" do
-      client = Riddle::Client.new
-      client.group_distinct = "id"
-      client.append_query "test "
-      client.queue.first.should == query_contents(:distinct)
-    end
-  
-    it "should build a message with weights correctly" do
-      client = Riddle::Client.new
-      client.weights = [100, 1]
-      client.append_query "test "
-      client.queue.first.should == query_contents(:weights)
-    end
-  
-    it "should build a message with an anchor correctly" do
-      client = Riddle::Client.new
-      client.set_anchor "latitude", 10.0, "longitude", 95.0
-      client.append_query "test "
-      client.queue.first.should == query_contents(:anchor)
-    end
-  
-    it "should build a message with index weights correctly" do
-      client = Riddle::Client.new
-      client.index_weights = {"people" => 101}
-      client.append_query "test "
-      client.queue.first.should == query_contents(:index_weights)
-    end
-  
-    it "should build a message with field weights correctly" do
-      client = Riddle::Client.new
-      client.field_weights = {"city" => 101}
-      client.append_query "test "
-      client.queue.first.should == query_contents(:field_weights)
-    end
-  
-    it "should build a message with a comment correctly" do
-      client = Riddle::Client.new
-      client.append_query "test ", "*", "commenting"
-      client.queue.first.should == query_contents(:comment)
-    end
-  
-    if Riddle.loaded_version == '0.9.9' || Riddle.loaded_version == '1.10'
-      it "should build a message with overrides correctly" do
-        client = Riddle::Client.new
-        client.add_override("rating", :float, {1 => 10.0})
-        client.append_query "test "
-        client.queue.first.should == query_contents(:overrides)
-      end
-  
-      it "should build a message with selects correctly" do
-        client = Riddle::Client.new
-        client.select = "selecting"
-        client.append_query "test "
-        client.queue.first.should == query_contents(:select)
-      end
-    end
-  
-    it "should keep multiple messages in the queue" do
-      client = Riddle::Client.new
-      client.weights = [100, 1]
-      client.append_query "test "
-      client.append_query "test "
-      client.queue.length.should == 2
-      client.queue.each { |item| item.should == query_contents(:weights) }
-    end
-  
-    it "should keep multiple messages in the queue with different params" do
-      client = Riddle::Client.new
-      client.weights = [100, 1]
-      client.append_query "test "
-      client.weights = []
-      client.append_query "test ", "edition"
-      client.queue.first.should == query_contents(:weights)
-      client.queue.last.should  == query_contents(:index)
-    end
-  
-    it "should build a basic update message correctly" do
-      client = Riddle::Client.new
-      client.send(
-        :update_message,
-        "people",
-        ["birthday"],
-        {1 => [191163600]}
-      ).should == query_contents(:update_simple)
-    end
-  
-    it "should build a keywords request without hits correctly" do
-      client = Riddle::Client.new
-      client.send(
-        :keywords_message,
-        "pat",
-        "people",
-        false
-      ).should == query_contents(:keywords_without_hits)
-    end
-  
-    it "should build a keywords request with hits correctly" do
-      client = Riddle::Client.new
-      client.send(
-        :keywords_message,
-        "pat",
-        "people",
-        true
-      ).should == query_contents(:keywords_with_hits)
-    end
-  end
-  
-  it "should timeout after a specified time" do
-    client = Riddle::Client.new
-    client.port     = 9314
-    client.timeout  = 1
-    
-    server = TCPServer.new "localhost", 9314
-    
-    lambda {
-      client.send(:connect) { |socket| }
-    }.should raise_error(Riddle::ConnectionError)
-    
-    server.close
-  end unless RUBY_PLATFORM == 'java' # JRuby doesn't like Timeout
-
-  context "connection retrying" do
-    it "should try fives time when connection refused" do
-      client = Riddle::Client.new
-      client.port    = 3314
-
-      TCPSocket.should_receive(:new).with('localhost', 3314).exactly(5).times.
-        and_raise(Errno::ECONNREFUSED)
-
-      lambda {
-        client.send(:connect) { |socket| }
-      }.should raise_error(Riddle::ConnectionError)
-    end
-  end
-
-  context "connection fail over" do
-    it "should try each of several server addresses after timeouts" do
-      client = Riddle::Client.new
-      client.port    = 3314
-      client.servers = %w[localhost 127.0.0.1 0.0.0.0]
-      client.timeout  = 1
-
-      TCPSocket.should_receive(:new).with(
-        an_instance_of(String), 3314
-      ).exactly(3).and_raise Timeout::Error
-
-      lambda {
-        client.send(:connect) { |socket| }
-      }.should raise_error(Riddle::ConnectionError)
-    end unless RUBY_PLATFORM == 'java' # JRuby doesn't like Timeout
-
-    it "should try each of several server addresses after a connection refused" do
-      client = Riddle::Client.new
-      client.port    = 3314
-      client.servers = %w[localhost 127.0.0.1 0.0.0.0]
-      client.timeout  = 1
-
-      # initialise_socket will retry 5 times before failing,
-      # these combined with the multiple server failover should result in 15
-      # calls to TCPSocket.new
-      TCPSocket.should_receive(:new).with(
-        an_instance_of(String), 3314
-      ).exactly(3 * 5).and_raise Errno::ECONNREFUSED
-
-      lambda {
-        client.send(:connect) { |socket| }
-      }.should raise_error(Riddle::ConnectionError)
-    end unless RUBY_PLATFORM == 'java' # JRuby doesn't like Timeout
-  end
-
-  it "should fail if the server has the wrong version" do
-    client = Riddle::Client.new
-    client.port     = 9314
-    client.timeout  = 1
-
-    server = TCPServer.new "localhost", 9314
-
-    thread = Thread.new do
-      client = server.accept
-      client.send [0].pack("N"), 0
-      client.close
-    end
-
-    lambda {
-      client.send(:connect) { |socket| }
-    }.should raise_error(Riddle::VersionError)
-
-    thread.exit
-    server.close
-  end
-
-end