sphinx 0.9.10 → 0.9.10.2043

data/lib/sphinx/server.rb

@@ -0,0 +1,167 @@
+class Sphinx::Server
+  # The host the Sphinx server is running on
+  attr_reader :host
+
+  # The port the Sphinx server is listening on
+  attr_reader :port
+
+  # The path to UNIX socket where Sphinx server is running on
+  attr_reader :path
+  
+  # Creates a new instance of +Server+.
+  #
+  # Parameters:
+  # * +sphinx+ -- an instance of <tt>Sphinx::Client</tt>.
+  # * +host+ -- name of host where search is running (if +path+ is not specified).
+  # * +port+ -- searchd port (if +path+ is not specified).
+  # * +path+ -- an absolute path to the UNIX socket.
+  #
+  def initialize(sphinx, host, port, path)
+    @sphinx = sphinx
+    @host = host
+    @port = port
+    @path = path
+    
+    @timeout = @sphinx.timeout
+    @retries = @sphinx.retries
+    
+    @reqtimeout = @sphinx.reqtimeout
+    @reqretries = @sphinx.reqretries
+    
+    @socket = nil
+  end
+  
+  # Gets the opened socket to the server.
+  #
+  # You can pass a block to make any connection establishing related things,
+  # like protocol version interchange. They will be treated as a part of
+  # connection routine, so connection timeout will include them.
+  #
+  # In case of connection error, +SphinxConnectError+ exception will be raised.
+  #
+  # Method returns opened socket, so do not forget to close it using +free_socket+
+  # method. Make sure you will close socket in case of any emergency.
+  #
+  def get_socket(&block)
+    if persistent?
+      yield @socket
+      @socket
+    else
+      socket = nil
+      Sphinx::safe_execute(@timeout) do
+        socket = establish_connection
+
+        # Do custom initialization
+        yield socket if block_given?
+      end
+      socket
+    end
+  rescue SocketError, SystemCallError, IOError, EOFError, ::Timeout::Error, ::Errno::EPIPE => e
+    # Close previously opened socket (in case of it has been really opened)
+    free_socket(socket, true)
+    
+    location = @path || "#{@host}:#{@port}"
+    error = "connection to #{location} failed ("
+    if e.kind_of?(SystemCallError)
+      error << "errno=#{e.class::Errno}, "
+    end
+    error << "msg=#{e.message})"
+    raise SphinxConnectError, error
+  end
+  
+  # Closes previously opened socket.
+  #
+  # Pass socket retrieved with +get_socket+ method when finished work. It does
+  # not close persistent sockets, but if really you need to do it, pass +true+
+  # as +force+ parameter value.
+  # 
+  def free_socket(socket, force = false)
+    # Socket has not been open
+    return false if socket.nil?
+    
+    # Do we try to close persistent socket?
+    if socket == @socket
+      # do not close it if not forced
+      if force
+        @socket.close unless @socket.closed?
+        @socket = nil
+        true
+      else
+        false
+      end
+    else
+      # Just close this socket
+      socket.close unless socket.closed?
+      true
+    end
+  end
+  
+  # Makes specified socket persistent.
+  #
+  # Previous persistent socket will be closed as well.
+  def make_persistent!(socket)
+    free_socket(@socket)
+    @socket = socket
+  end
+  
+  # Closes persistent socket.
+  def close_persistent!
+    if @socket
+      @socket.close unless @socket.closed?
+      @socket = nil
+      true
+    else
+      false
+    end
+  end
+  
+  # Gets a value indicating whether server has persistent socket associated.
+  def persistent?
+    !@socket.nil?
+  end
+  
+  private
+  
+    # This is internal method which establishes a connection to a configured server.
+    #
+    # Method configures various socket options (like TCP_NODELAY), and
+    # sets socket timeouts.
+    #
+    # It does not close socket on any failure, please do it from calling code!
+    # 
+    def establish_connection
+      if @path
+        sock = UNIXSocket.new(@path)
+      else
+        sock = TCPSocket.new(@host, @port)
+      end
+
+      io = Sphinx::BufferedIO.new(sock)
+      io.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      if @reqtimeout > 0
+        io.read_timeout = @reqtimeout
+    
+        # This is a part of memcache-client library.
+        #
+        # Getting reports from several customers, including 37signals,
+        # that the non-blocking timeouts in 1.7.5 don't seem to be reliable.
+        # It can't hurt to set the underlying socket timeout also, if possible.
+        if timeout
+          secs = Integer(timeout)
+          usecs = Integer((timeout - secs) * 1_000_000)
+          optval = [secs, usecs].pack("l_2")
+          begin
+            io.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
+            io.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
+          rescue Exception => ex
+            # Solaris, for one, does not like/support socket timeouts.
+            @warning = "Unable to use raw socket timeouts: #{ex.class.name}: #{ex.message}"
+          end
+        end
+      else
+        io.read_timeout = false
+      end
+      
+      io
+    end
+end

data/lib/sphinx/timeout.rb

@@ -0,0 +1,28 @@
+module Sphinx
+  begin
+    # Try to use the SystemTimer gem instead of Ruby's timeout library
+    # when running on something that looks like Ruby 1.8.x. See:
+    #   http://ph7spot.com/articles/system_timer
+    # We don't want to bother trying to load SystemTimer on jruby and
+    # ruby 1.9+
+    if defined?(JRUBY_VERSION) || (RUBY_VERSION >= '1.9')
+      require 'timeout'
+      Timeout = ::Timeout
+    else
+      require 'system_timer'
+      Timeout = ::SystemTimer
+    end
+  rescue LoadError => e
+    puts "[sphinx] Could not load SystemTimer gem, falling back to Ruby's slower/unsafe timeout library: #{e.message}"
+    require 'timeout'
+    Timeout = ::Timeout
+  end
+  
+  def self.safe_execute(timeout = 5, &block)
+    if timeout > 0
+      Sphinx::Timeout.timeout(timeout, &block)
+    else
+      yield
+    end
+  end
+end

data/spec/client_response_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../init'
+require File.dirname(__FILE__) + '/spec_helper'
 
 # To execute these tests you need to execute sphinx_test.sql and configure sphinx using sphinx.conf
 # (both files are placed under sphinx directory)
@@ -24,7 +24,7 @@ describe Sphinx::Client, 'connected' do
 
     it 'should process errors in Query method' do
       @sphinx.Query('wifi', 'fakeindex').should be_false
-      @sphinx.GetLastError.length.should_not == 0
+      @sphinx.GetLastError.should_not be_empty
     end
   end
   
@@ -34,14 +34,14 @@ describe Sphinx::Client, 'connected' do
       @sphinx.AddQuery('gprs', 'test1')
       results = @sphinx.RunQueries
       results.should be_an_instance_of(Array)
-      results.length.should == 2
+      results.should have(2).items
       validate_results_wifi(results[0])
     end
 
     it 'should process errors in RunQueries method' do
       @sphinx.AddQuery('wifi', 'fakeindex')
       r = @sphinx.RunQueries
-      r[0]['error'].length.should_not == 0
+      r[0]['error'].should_not be_empty
     end
   end
 
@@ -62,25 +62,6 @@ describe Sphinx::Client, 'connected' do
     end
   end
 
-  context 'in Open method' do
-    it 'should open socket' do
-      @sphinx.Open.should be_true
-      socket = @sphinx.instance_variable_get(:@socket)
-      socket.should be_kind_of(TCPSocket)
-      socket.close
-    end
-
-    it 'should produce an error when opened twice' do
-      @sphinx.Open.should be_true
-      @sphinx.Open.should be_false
-      @sphinx.GetLastError.should == 'already connected'
-
-      socket = @sphinx.instance_variable_get(:@socket)
-      socket.should be_kind_of(TCPSocket)
-      socket.close
-    end
-  end
-
   context 'in UpdateAttributes method' do
     it 'should parse response' do
       @sphinx.UpdateAttributes('test1', ['group_id'], { 2 => [1] }).should == 1
@@ -101,23 +82,43 @@ describe Sphinx::Client, 'connected' do
     end
   end
 
+  context 'in Open method' do
+    it 'should open socket' do
+      @sphinx.Open.should be_true
+      socket = @sphinx.servers.first.instance_variable_get(:@socket)
+      socket.should_not be_nil
+      socket.should be_kind_of(Sphinx::BufferedIO)
+      socket.close
+    end
+  
+    it 'should produce an error when opened twice' do
+      @sphinx.Open.should be_true
+      @sphinx.Open.should be_false
+      @sphinx.GetLastError.should == 'already connected'
+  
+      socket = @sphinx.servers.first.instance_variable_get(:@socket)
+      socket.should be_kind_of(Sphinx::BufferedIO)
+      socket.close
+    end
+  end
+  
   context 'in Close method' do
     it 'should open socket' do
       @sphinx.Open.should be_true
       @sphinx.Close.should be_true
-      @sphinx.instance_variable_get(:@socket).should be_false
+      @sphinx.servers.first.instance_variable_get(:@socket).should be_nil
     end
-
+  
     it 'should produce socket is closed' do
       @sphinx.Close.should be_false
       @sphinx.GetLastError.should == 'not connected'
-      @sphinx.instance_variable_get(:@socket).should be_false
-
+      @sphinx.servers.first.instance_variable_get(:@socket).should be_nil
+  
       @sphinx.Open.should be_true
       @sphinx.Close.should be_true
       @sphinx.Close.should be_false
       @sphinx.GetLastError.should == 'not connected'
-      @sphinx.instance_variable_get(:@socket).should be_false
+      @sphinx.servers.first.instance_variable_get(:@socket).should be_nil
     end
   end
 

data/spec/client_spec.rb

@@ -1,471 +1,650 @@
-require File.dirname(__FILE__) + '/../init'
-
-class SphinxSpecError < StandardError; end
-
-module SphinxFixtureHelper
-  def sphinx_fixture(name)
-    `php #{File.dirname(__FILE__)}/fixtures/#{name}.php`
-  end
-end
-
-module SphinxApiCall
-  def create_sphinx
-    @sphinx = Sphinx::Client.new
-    @sock = mock('TCPSocket')
-    @sphinx.stub!(:Connect).and_return(@sock)
-    @sphinx.stub!(:GetResponse).and_raise(SphinxSpecError)
-    return @sphinx
-  end
-
-  def safe_call
-    yield
-  rescue SphinxSpecError
-  end
-end
-
-describe 'The Connect method of Sphinx::Client' do
-  before(:each) do
-    @sphinx = Sphinx::Client.new
-    @sock = mock('TCPSocket')
-  end
-
-  it 'should establish TCP connection to the server and initialize session' do
-    TCPSocket.should_receive(:new).with('localhost', 3312).and_return(@sock)
-    @sock.should_receive(:recv).with(4).and_return([1].pack('N'))
-    @sock.should_receive(:send).with([1].pack('N'), 0)
-    @sphinx.send(:Connect).should be(@sock)
-  end
-
-  it 'should raise exception when searchd protocol is not 1+' do
-    TCPSocket.should_receive(:new).with('localhost', 3312).and_return(@sock)
-    @sock.should_receive(:send).with([1].pack('N'), 0)
-    @sock.should_receive(:recv).with(4).and_return([0].pack('N'))
-    @sock.should_receive(:close)
-    lambda { @sphinx.send(:Connect) }.should raise_error(Sphinx::SphinxConnectError)
-    @sphinx.GetLastError.should == 'expected searchd protocol version 1+, got version \'0\''
-  end
-
-  it 'should raise exception on connection error' do
-    TCPSocket.should_receive(:new).with('localhost', 3312).and_raise(Errno::EBADF)
-    lambda { @sphinx.send(:Connect) }.should raise_error(Sphinx::SphinxConnectError)
-    @sphinx.GetLastError.should == 'connection to localhost:3312 failed (errno=9, msg=Bad file descriptor)'
-  end
-
-  it 'should use custom host and port' do
-    @sphinx.SetServer('anotherhost', 55555)
-    TCPSocket.should_receive(:new).with('anotherhost', 55555).and_raise(Errno::EBADF)
-    lambda { @sphinx.send(:Connect) }.should raise_error(Sphinx::SphinxConnectError)
-  end
-end
-
-describe 'The GetResponse method of Sphinx::Client' do
-  before(:each) do
-    @sphinx = Sphinx::Client.new
-    @sock = mock('TCPSocket')
-    @sock.should_receive(:close)
-  end
-  
-  it 'should receive response' do
-    @sock.should_receive(:recv).with(8).and_return([Sphinx::Client::SEARCHD_OK, 1, 4].pack('n2N'))
-    @sock.should_receive(:recv).with(4).and_return([0].pack('N'))
-    @sphinx.send(:GetResponse, @sock, 1)
-  end
-
-  it 'should raise exception on zero-sized response' do
-    @sock.should_receive(:recv).with(8).and_return([Sphinx::Client::SEARCHD_OK, 1, 0].pack('n2N'))
-    lambda { @sphinx.send(:GetResponse, @sock, 1) }.should raise_error(Sphinx::SphinxResponseError)
-  end
-
-  it 'should raise exception when response is incomplete' do
-    @sock.should_receive(:recv).with(8).and_return([Sphinx::Client::SEARCHD_OK, 1, 4].pack('n2N'))
-    @sock.should_receive(:recv).with(4).and_raise(EOFError)
-    lambda { @sphinx.send(:GetResponse, @sock, 1) }.should raise_error(Sphinx::SphinxResponseError)
-  end
-
-  it 'should set warning message when SEARCHD_WARNING received' do
-    @sock.should_receive(:recv).with(8).and_return([Sphinx::Client::SEARCHD_WARNING, 1, 14].pack('n2N'))
-    @sock.should_receive(:recv).with(14).and_return([5].pack('N') + 'helloworld')
-    @sphinx.send(:GetResponse, @sock, 1).should == 'world'
-    @sphinx.GetLastWarning.should == 'hello'
-  end
-
-  it 'should raise exception when SEARCHD_ERROR received' do
-    @sock.should_receive(:recv).with(8).and_return([Sphinx::Client::SEARCHD_ERROR, 1, 9].pack('n2N'))
-    @sock.should_receive(:recv).with(9).and_return([1].pack('N') + 'hello')
-    lambda { @sphinx.send(:GetResponse, @sock, 1) }.should raise_error(Sphinx::SphinxInternalError)
-    @sphinx.GetLastError.should == 'searchd error: hello'
-  end
-
-  it 'should raise exception when SEARCHD_RETRY received' do
-    @sock.should_receive(:recv).with(8).and_return([Sphinx::Client::SEARCHD_RETRY, 1, 9].pack('n2N'))
-    @sock.should_receive(:recv).with(9).and_return([1].pack('N') + 'hello')
-    lambda { @sphinx.send(:GetResponse, @sock, 1) }.should raise_error(Sphinx::SphinxTemporaryError)
-    @sphinx.GetLastError.should == 'temporary searchd error: hello'
-  end
-
-  it 'should raise exception when unknown status received' do
-    @sock.should_receive(:recv).with(8).and_return([65535, 1, 9].pack('n2N'))
-    @sock.should_receive(:recv).with(9).and_return([1].pack('N') + 'hello')
-    lambda { @sphinx.send(:GetResponse, @sock, 1) }.should raise_error(Sphinx::SphinxUnknownError)
-    @sphinx.GetLastError.should == 'unknown status code: \'65535\''
-  end
-
-  it 'should set warning when server is older than client' do
-    @sock.should_receive(:recv).with(8).and_return([Sphinx::Client::SEARCHD_OK, 1, 9].pack('n2N'))
-    @sock.should_receive(:recv).with(9).and_return([1].pack('N') + 'hello')
-    @sphinx.send(:GetResponse, @sock, 5)
-    @sphinx.GetLastWarning.should == 'searchd command v.0.1 older than client\'s v.0.5, some options might not work'
-  end
-end
-
-describe 'The Query method of Sphinx::Client' do
-  include SphinxFixtureHelper
-  include SphinxApiCall
-
-  before(:each) do
-    @sphinx = create_sphinx
-  end
-
-  it 'should generate valid request with default parameters' do
-    expected = sphinx_fixture('default_search')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with default parameters and index' do
-    expected = sphinx_fixture('default_search_index')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.Query('query', 'index') rescue nil?
-  end
-  
-  it 'should generate valid request with limits' do
-    expected = sphinx_fixture('limits')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetLimits(10, 20)
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with limits and max number to retrieve' do
-    expected = sphinx_fixture('limits_max')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetLimits(10, 20, 30)
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with limits and cutoff to retrieve' do
-    expected = sphinx_fixture('limits_cutoff')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetLimits(10, 20, 30, 40)
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with max query time specified' do
-    expected = sphinx_fixture('max_query_time')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetMaxQueryTime(1000)
-    @sphinx.Query('query') rescue nil?
-  end
-
-  describe 'with match' do
-    [ :all, :any, :phrase, :boolean, :extended, :fullscan, :extended2 ].each do |match|
-      it "should generate valid request for SPH_MATCH_#{match.to_s.upcase}" do
-        expected = sphinx_fixture("match_#{match}")
-        @sock.should_receive(:send).with(expected, 0)
-        @sphinx.SetMatchMode(Sphinx::Client::const_get("SPH_MATCH_#{match.to_s.upcase}"))
-        @sphinx.Query('query') rescue nil?
-      end
-    end
-  end
-
-  describe 'with rank' do
-    [ :proximity_bm25, :bm25, :none, :wordcount, :proximity, :matchany, :fieldmask, :sph04 ].each do |rank|
-      it "should generate valid request for SPH_RANK_#{rank.to_s.upcase}" do
-        expected = sphinx_fixture("ranking_#{rank}")
-        @sock.should_receive(:send).with(expected, 0)
-        @sphinx.SetRankingMode(Sphinx::Client.const_get("SPH_RANK_#{rank.to_s.upcase}"))
-        @sphinx.Query('query') rescue nil?
-      end
-    end
-  end
-
-  describe 'with sorting' do
-    [ :attr_desc, :relevance, :attr_asc, :time_segments, :extended, :expr ].each do |mode|
-      it "should generate valid request for SPH_SORT_#{mode.to_s.upcase}" do
-        expected = sphinx_fixture("sort_#{mode}")
-        @sock.should_receive(:send).with(expected, 0)
-        @sphinx.SetSortMode(Sphinx::Client.const_get("SPH_SORT_#{mode.to_s.upcase}"), mode == :relevance ? '' : 'sortby')
-        @sphinx.Query('query') rescue nil?
-      end
-    end
-  end
-
-  it 'should generate valid request with weights' do
-    expected = sphinx_fixture('weights')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetWeights([10, 20, 30, 40])
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with field weights' do
-    expected = sphinx_fixture('field_weights')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetFieldWeights({'field1' => 10, 'field2' => 20})
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with index weights' do
-    expected = sphinx_fixture('index_weights')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetIndexWeights({'index1' => 10, 'index2' => 20})
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with ID range' do
-    expected = sphinx_fixture('id_range')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetIDRange(10, 20)
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with ID range and 64-bit ints' do
-    expected = sphinx_fixture('id_range64')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetIDRange(8589934591, 17179869183)
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with values filter' do
-    expected = sphinx_fixture('filter')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetFilter('attr', [10, 20, 30])
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with two values filters' do
-    expected = sphinx_fixture('filters')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetFilter('attr2', [40, 50])
-    @sphinx.SetFilter('attr1', [10, 20, 30])
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with values filter excluded' do
-    expected = sphinx_fixture('filter_exclude')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetFilter('attr', [10, 20, 30], true)
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with values filter range' do
-    expected = sphinx_fixture('filter_range')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetFilterRange('attr', 10, 20)
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with two filter ranges' do
-    expected = sphinx_fixture('filter_ranges')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetFilterRange('attr2', 30, 40)
-    @sphinx.SetFilterRange('attr1', 10, 20)
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with filter range excluded' do
-    expected = sphinx_fixture('filter_range_exclude')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetFilterRange('attr', 10, 20, true)
-    @sphinx.Query('query') rescue nil?
-  end
-  
-  it 'should generate valid request with signed int64-based filter range' do
-    expected = sphinx_fixture('filter_range_int64')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetFilterRange('attr1', -10, 20)
-    @sphinx.SetFilterRange('attr2', -1099511627770, 1099511627780)
-    safe_call { @sphinx.Query('query') }
-  end
-
-  it 'should generate valid request with float filter range' do
-    expected = sphinx_fixture('filter_float_range')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetFilterFloatRange('attr', 10.5, 20.3)
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with float filter excluded' do
-    expected = sphinx_fixture('filter_float_range_exclude')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetFilterFloatRange('attr', 10.5, 20.3, true)
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with different filters' do
-    expected = sphinx_fixture('filters_different')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetFilterRange('attr1', 10, 20, true)
-    @sphinx.SetFilter('attr3', [30, 40, 50])
-    @sphinx.SetFilterRange('attr1', 60, 70)
-    @sphinx.SetFilter('attr2', [80, 90, 100], true)
-    @sphinx.SetFilterFloatRange('attr1', 60.8, 70.5)
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with geographical anchor point' do
-    expected = sphinx_fixture('geo_anchor')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetGeoAnchor('attrlat', 'attrlong', 20.3, 40.7)
-    @sphinx.Query('query') rescue nil?
-  end
-  
-  describe 'with group by' do
-    [ :day, :week, :month, :year, :attr, :attrpair ].each do |groupby|
-      it "should generate valid request for SPH_GROUPBY_#{groupby.to_s.upcase}" do
-        expected = sphinx_fixture("group_by_#{groupby}")
-        @sock.should_receive(:send).with(expected, 0)
-        @sphinx.SetGroupBy('attr', Sphinx::Client::const_get("SPH_GROUPBY_#{groupby.to_s.upcase}"))
-        @sphinx.Query('query') rescue nil?
-      end
-    end
-
-    it 'should generate valid request for SPH_GROUPBY_DAY with sort' do
-      expected = sphinx_fixture('group_by_day_sort')
-      @sock.should_receive(:send).with(expected, 0)
-      @sphinx.SetGroupBy('attr', Sphinx::Client::SPH_GROUPBY_DAY, 'somesort')
-      @sphinx.Query('query') rescue nil?
-    end
-
-    it 'should generate valid request with count-distinct attribute' do
-      expected = sphinx_fixture('group_distinct')
-      @sock.should_receive(:send).with(expected, 0)
-      @sphinx.SetGroupBy('attr', Sphinx::Client::SPH_GROUPBY_DAY)
-      @sphinx.SetGroupDistinct('attr')
-      @sphinx.Query('query') rescue nil?
-    end
-  end
-
-  it 'should generate valid request with retries count specified' do
-    expected = sphinx_fixture('retries')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetRetries(10)
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request with retries count and delay specified' do
-    expected = sphinx_fixture('retries_delay')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetRetries(10, 20)
-    @sphinx.Query('query') rescue nil?
-  end
-  
-  it 'should generate valid request for SetOverride' do
-    expected = sphinx_fixture('set_override')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetOverride('attr1', Sphinx::Client::SPH_ATTR_INTEGER, { 10 => 20 })
-    @sphinx.SetOverride('attr2', Sphinx::Client::SPH_ATTR_FLOAT, { 11 => 30.3 })
-    @sphinx.SetOverride('attr3', Sphinx::Client::SPH_ATTR_BIGINT, { 12 => 1099511627780 })
-    @sphinx.Query('query') rescue nil?
-  end
-
-  it 'should generate valid request for SetSelect' do
-    expected = sphinx_fixture('select')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.SetSelect('attr1, attr2')
-    @sphinx.Query('query') rescue nil?
-  end
-end
-
-describe 'The RunQueries method of Sphinx::Client' do
-  include SphinxFixtureHelper
-
-  before(:each) do
-    @sphinx = Sphinx::Client.new
-    @sock = mock('TCPSocket')
-    @sphinx.stub!(:Connect).and_return(@sock)
-    @sphinx.stub!(:GetResponse).and_raise(Sphinx::SphinxError)
-  end
-
-  it 'should generate valid request for multiple queries' do
-    expected = sphinx_fixture('miltiple_queries')
-    @sock.should_receive(:send).with(expected, 0)
-    
-    @sphinx.SetRetries(10, 20)
-    @sphinx.AddQuery('test1')
-    @sphinx.SetGroupBy('attr', Sphinx::Client::SPH_GROUPBY_DAY)
-    @sphinx.AddQuery('test2') rescue nil?
-    
-    @sphinx.RunQueries rescue nil?
-  end
-end
-
-describe 'The BuildExcerpts method of Sphinx::Client' do
-  include SphinxFixtureHelper
-
-  before(:each) do
-    @sphinx = Sphinx::Client.new
-    @sock = mock('TCPSocket')
-    @sphinx.stub!(:Connect).and_return(@sock)
-    @sphinx.stub!(:GetResponse).and_raise(Sphinx::SphinxError)
-  end
-  
-  it 'should generate valid request with default parameters' do
-    expected = sphinx_fixture('excerpt_default')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.BuildExcerpts(['10', '20'], 'index', 'word1 word2') rescue nil?
-  end
-
-  it 'should generate valid request with custom parameters' do
-    expected = sphinx_fixture('excerpt_custom')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.BuildExcerpts(['10', '20'], 'index', 'word1 word2', { 'before_match'    => 'before',
-                                                                  'after_match'     => 'after',
-                                                                  'chunk_separator' => 'separator',
-                                                                  'limit'           => 10 }) rescue nil?
-  end
-  
-  it 'should generate valid request with flags' do
-    expected = sphinx_fixture('excerpt_flags')
-    @sock.should_receive(:send).with(expected, 0)
-    @sphinx.BuildExcerpts(['10', '20'], 'index', 'word1 word2', { 'exact_phrase'   => true,
-                                                                  'single_passage' => true,
-                                                                  'use_boundaries' => true,
-                                                                  'weight_order'   => true,
-                                                                  'query_mode'     => true }) rescue nil?
-  end
-end
-
-describe 'The BuildKeywords method of Sphinx::Client' do
-  include SphinxFixtureHelper
-  include SphinxApiCall
-
-  before(:each) do
-    @sphinx = create_sphinx
-  end
-  
-  it 'should generate valid request' do
-    expected = sphinx_fixture('keywords')
-    @sock.should_receive(:send).with(expected, 0)
-    safe_call { @sphinx.BuildKeywords('test', 'index', true) }
-  end
-end
-
-describe 'The UpdateAttributes method of Sphinx::Client' do
-  include SphinxFixtureHelper
-  include SphinxApiCall
-
-  before(:each) do
-    @sphinx = create_sphinx
-  end
-  
-  it 'should generate valid request' do
-    expected = sphinx_fixture('update_attributes')
-    @sock.should_receive(:send).with(expected, 0)
-    safe_call { @sphinx.UpdateAttributes('index', ['group'], { 123 => [456] }) }
-  end
-  
-  it 'should generate valid request for MVA' do
-    expected = sphinx_fixture('update_attributes_mva')
-    @sock.should_receive(:send).with(expected, 0)
-    safe_call { @sphinx.UpdateAttributes('index', ['group', 'category'], { 123 => [ [456, 789], [1, 2, 3] ] }, true) }
-  end
-end
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Sphinx::Client, 'disconnected' do
+  context 'in with_server method' do
+    before :each do
+      @sphinx = Sphinx::Client.new
+      @servers = [{:host => 'localhost', :port => 1}, {:host => 'localhost', :port => 2}]
+    end
+
+    context 'without retries' do
+      it 'should use single Server instance' do
+        2.times do
+          cnt = 0
+          @sphinx.send(:with_server) { |server| cnt += 1; server.should == @sphinx.servers[0] }
+          cnt.should == 1
+        end
+      end
+      
+      it 'should raise an exception on error' do
+        2.times do
+          cnt = 0
+          expect {
+            @sphinx.send(:with_server) { |server| cnt += 1; server.should == @sphinx.servers[0]; raise Sphinx::SphinxConnectError }
+          }.to raise_error(Sphinx::SphinxConnectError)
+          cnt.should == 1
+        end
+      end
+
+      it 'should round-robin servers on each call' do
+        @sphinx.SetServers(@servers)
+        cnt = 0
+        @sphinx.send(:with_server) { |server| cnt += 1; server.should == @sphinx.servers[0] }
+        cnt.should == 1
+        cnt = 0
+        @sphinx.send(:with_server) { |server| cnt += 1; server.should == @sphinx.servers[1] }
+        cnt.should == 1
+        cnt = 0
+        @sphinx.send(:with_server) { |server| cnt += 1; server.should == @sphinx.servers[0] }
+        cnt.should == 1
+      end
+
+      it 'should round-robin servers and raise an exception on error' do
+        @sphinx.SetServers(@servers)
+        cnt = 0
+        expect {
+          @sphinx.send(:with_server) { |server| cnt += 1; server.should == @sphinx.servers[0]; raise Sphinx::SphinxConnectError }
+        }.to raise_error(Sphinx::SphinxConnectError)
+        cnt.should == 1
+        cnt = 0
+        expect {
+          @sphinx.send(:with_server) { |server| cnt += 1; server.should == @sphinx.servers[1]; raise Sphinx::SphinxConnectError }
+        }.to raise_error(Sphinx::SphinxConnectError)
+        cnt.should == 1
+        cnt = 0
+        expect {
+          @sphinx.send(:with_server) { |server| cnt += 1; server.should == @sphinx.servers[0]; raise Sphinx::SphinxConnectError }
+        }.to raise_error(Sphinx::SphinxConnectError)
+        cnt.should == 1
+      end
+    end
+
+    context 'with retries' do
+      before :each do
+        @sphinx.SetConnectTimeout(0, 3)
+      end
+
+      it 'should raise an exception on error' do
+        cnt = 0
+        expect {
+          @sphinx.send(:with_server) { |server| cnt += 1; server.should == @sphinx.servers[0]; raise Sphinx::SphinxConnectError }
+        }.to raise_error(Sphinx::SphinxConnectError)
+        cnt.should == 3
+      end
+
+      it 'should round-robin servers and raise an exception on error' do
+        @sphinx.SetServers(@servers)
+        cnt = 0
+        expect {
+          @sphinx.send(:with_server) { |server| cnt += 1; server.should == @sphinx.servers[(cnt - 1) % 2]; raise Sphinx::SphinxConnectError }
+        }.to raise_error(Sphinx::SphinxConnectError)
+        cnt.should == 3
+      end
+    end
+  end
+  
+  context 'in with_socket method' do
+    before :each do
+      @sphinx = Sphinx::Client.new
+      @socket = mock('TCPSocket')
+    end
+    
+    context 'without retries' do
+      before :each do
+        @server = mock('Server')
+        @server.should_receive(:get_socket).and_yield(@socket).and_return(@socket)
+        @server.should_receive(:free_socket).with(@socket).at_least(1)
+      end
+      
+      it 'should initialize session' do
+        @socket.should_receive(:write).with([1].pack('N'))
+        @socket.should_receive(:read).with(4).and_return([1].pack('N'))
+        cnt = 0
+        @sphinx.send(:with_socket, @server) { |socket| cnt += 1; socket.should == @socket }
+        cnt.should == 1
+      end
+
+      it 'should raise exception when searchd protocol is not 1+' do
+        @socket.should_receive(:write).with([1].pack('N'))
+        @socket.should_receive(:read).with(4).and_return([0].pack('N'))
+        cnt = 0
+        expect {
+          @sphinx.send(:with_socket, @server) { cnt += 1; }
+        }.to raise_error(Sphinx::SphinxConnectError, 'expected searchd protocol version 1+, got version \'0\'')
+        cnt.should == 0
+      end
+
+      it 'should handle request timeouts' do
+        @socket.should_receive(:write).with([1].pack('N'))
+        @socket.should_receive(:read).with(4).and_return([1].pack('N'))
+        @sphinx.SetRequestTimeout(1)
+        cnt = 0
+        expect {
+          @sphinx.send(:with_socket, @server) { cnt += 1; sleep 2 }
+        }.to raise_error(Sphinx::SphinxResponseError, 'failed to read searchd response (msg=time\'s up!)')
+        cnt.should == 1
+
+        @sphinx.GetLastError.should == 'failed to read searchd response (msg=time\'s up!)'
+        @sphinx.IsConnectError.should be_false
+      end
+
+      it 'should re-reaise Sphinx errors' do
+        @socket.should_receive(:write).with([1].pack('N'))
+        @socket.should_receive(:read).with(4).and_return([1].pack('N'))
+        cnt = 0
+        expect {
+          @sphinx.send(:with_socket, @server) { cnt += 1; raise Sphinx::SphinxInternalError, 'hello' }
+        }.to raise_error(Sphinx::SphinxInternalError, 'hello')
+        cnt.should == 1
+
+        @sphinx.GetLastError.should == 'hello'
+        @sphinx.IsConnectError.should be_false
+      end
+    end
+
+    context 'with retries' do
+      before :each do
+        @sphinx.SetRequestTimeout(0, 3)
+        # two more times yielding - retries
+        @server = mock('Server')
+        @server.should_receive(:get_socket).at_least(1).times.and_yield(@socket).and_return(@socket)
+        @server.should_receive(:free_socket).with(@socket).at_least(1)
+      end
+      
+      it 'should raise an exception on error' do
+        @socket.should_receive(:write).exactly(3).times.with([1].pack('N'))
+        @socket.should_receive(:read).exactly(3).times.with(4).and_return([1].pack('N'))
+        cnt = 0
+        expect {
+          @sphinx.send(:with_socket, @server) { cnt += 1; raise Sphinx::SphinxInternalError, 'hello' }
+        }.to raise_error(Sphinx::SphinxInternalError, 'hello')
+        cnt.should == 3
+
+        @sphinx.GetLastError.should == 'hello'
+        @sphinx.IsConnectError.should be_false
+      end
+    end
+  end
+    
+  context 'in parse_response method' do
+    before :each do
+      @sphinx = Sphinx::Client.new
+      @socket = mock('TCPSocket')
+    end
+
+    it 'should receive response' do
+      @socket.should_receive(:read).with(8).and_return([Sphinx::Client::SEARCHD_OK, 1, 4].pack('n2N'))
+      @socket.should_receive(:read).with(4).and_return([0].pack('N'))
+      @sphinx.send(:parse_response, @socket, 1)
+    end
+
+    it 'should raise exception on zero-sized response' do
+      @socket.should_receive(:read).with(8).and_return([Sphinx::Client::SEARCHD_OK, 1, 0].pack('n2N'))
+      expect {
+        @sphinx.send(:parse_response, @socket, 1)
+      }.to raise_error(Sphinx::SphinxResponseError, 'received zero-sized searchd response')
+    end
+
+    it 'should raise exception when response is incomplete' do
+      @socket.should_receive(:read).with(8).and_return([Sphinx::Client::SEARCHD_OK, 1, 4].pack('n2N'))
+      @socket.should_receive(:read).with(4).and_return('')
+      expect {
+        @sphinx.send(:parse_response, @socket, 1)
+      }.to raise_error(Sphinx::SphinxResponseError)
+    end
+
+    it 'should set warning message when SEARCHD_WARNING received' do
+      @socket.should_receive(:read).with(8).and_return([Sphinx::Client::SEARCHD_WARNING, 1, 14].pack('n2N'))
+      @socket.should_receive(:read).with(14).and_return([5].pack('N') + 'helloworld')
+      @sphinx.send(:parse_response, @socket, 1).should == 'world'
+      @sphinx.GetLastWarning.should == 'hello'
+    end
+
+    it 'should raise exception when SEARCHD_ERROR received' do
+      @socket.should_receive(:read).with(8).and_return([Sphinx::Client::SEARCHD_ERROR, 1, 9].pack('n2N'))
+      @socket.should_receive(:read).with(9).and_return([1].pack('N') + 'hello')
+      expect {
+        @sphinx.send(:parse_response, @socket, 1)
+      }.to raise_error(Sphinx::SphinxInternalError, 'searchd error: hello')
+    end
+
+    it 'should raise exception when SEARCHD_RETRY received' do
+      @socket.should_receive(:read).with(8).and_return([Sphinx::Client::SEARCHD_RETRY, 1, 9].pack('n2N'))
+      @socket.should_receive(:read).with(9).and_return([1].pack('N') + 'hello')
+      expect {
+        @sphinx.send(:parse_response, @socket, 1)
+      }.to raise_error(Sphinx::SphinxTemporaryError, 'temporary searchd error: hello')
+    end
+
+    it 'should raise exception when unknown status received' do
+      @socket.should_receive(:read).with(8).and_return([65535, 1, 9].pack('n2N'))
+      @socket.should_receive(:read).with(9).and_return([1].pack('N') + 'hello')
+      expect {
+        @sphinx.send(:parse_response, @socket, 1)
+      }.to raise_error(Sphinx::SphinxUnknownError, 'unknown status code: \'65535\'')
+    end
+
+    it 'should set warning when server is older than client' do
+      @socket.should_receive(:read).with(8).and_return([Sphinx::Client::SEARCHD_OK, 1, 9].pack('n2N'))
+      @socket.should_receive(:read).with(9).and_return([1].pack('N') + 'hello')
+      @sphinx.send(:parse_response, @socket, 5)
+      @sphinx.GetLastWarning.should == 'searchd command v.0.1 older than client\'s v.0.5, some options might not work'
+    end
+  end
+
+  context 'in Query method' do
+    before :each do
+      @sphinx = sphinx_create_client
+    end
+
+    it 'should generate valid request with default parameters' do
+      expected = sphinx_fixture('default_search')
+      @sock.should_receive(:write).with(expected)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with default parameters and index' do
+      expected = sphinx_fixture('default_search_index')
+      @sock.should_receive(:write).with(expected)
+      sphinx_safe_call { @sphinx.Query('query', 'index') }
+    end
+
+    it 'should generate valid request with limits' do
+      expected = sphinx_fixture('limits')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetLimits(10, 20)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with limits and max number to retrieve' do
+      expected = sphinx_fixture('limits_max')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetLimits(10, 20, 30)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with limits and cutoff to retrieve' do
+      expected = sphinx_fixture('limits_cutoff')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetLimits(10, 20, 30, 40)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with max query time specified' do
+      expected = sphinx_fixture('max_query_time')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetMaxQueryTime(1000)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    describe 'with match' do
+      [ :all, :any, :phrase, :boolean, :extended, :fullscan, :extended2 ].each do |match|
+        it "should generate valid request for SPH_MATCH_#{match.to_s.upcase}" do
+          expected = sphinx_fixture("match_#{match}")
+          @sock.should_receive(:write).with(expected)
+          @sphinx.SetMatchMode(Sphinx::Client::const_get("SPH_MATCH_#{match.to_s.upcase}"))
+          sphinx_safe_call { @sphinx.Query('query') }
+        end
+
+        it "should generate valid request for \"#{match}\"" do
+          expected = sphinx_fixture("match_#{match}")
+          @sock.should_receive(:write).with(expected)
+          @sphinx.SetMatchMode(match.to_s)
+          sphinx_safe_call { @sphinx.Query('query') }
+        end
+
+        it "should generate valid request for :#{match}" do
+          expected = sphinx_fixture("match_#{match}")
+          @sock.should_receive(:write).with(expected)
+          @sphinx.SetMatchMode(match)
+          sphinx_safe_call { @sphinx.Query('query') }
+        end
+      end
+    end
+
+    describe 'with rank' do
+      [ :proximity_bm25, :bm25, :none, :wordcount, :proximity, :matchany, :fieldmask, :sph04 ].each do |rank|
+        it "should generate valid request for SPH_RANK_#{rank.to_s.upcase}" do
+          expected = sphinx_fixture("ranking_#{rank}")
+          @sock.should_receive(:write).with(expected)
+          @sphinx.SetRankingMode(Sphinx::Client.const_get("SPH_RANK_#{rank.to_s.upcase}"))
+          sphinx_safe_call { @sphinx.Query('query') }
+        end
+
+        it "should generate valid request for \"#{rank}\"" do
+          expected = sphinx_fixture("ranking_#{rank}")
+          @sock.should_receive(:write).with(expected)
+          @sphinx.SetRankingMode(rank.to_s)
+          sphinx_safe_call { @sphinx.Query('query') }
+        end
+
+        it "should generate valid request for :#{rank}" do
+          expected = sphinx_fixture("ranking_#{rank}")
+          @sock.should_receive(:write).with(expected)
+          @sphinx.SetRankingMode(rank)
+          sphinx_safe_call { @sphinx.Query('query') }
+        end
+      end
+    end
+
+    describe 'with sorting' do
+      [ :attr_desc, :relevance, :attr_asc, :time_segments, :extended, :expr ].each do |mode|
+        it "should generate valid request for SPH_SORT_#{mode.to_s.upcase}" do
+          expected = sphinx_fixture("sort_#{mode}")
+          @sock.should_receive(:write).with(expected)
+          @sphinx.SetSortMode(Sphinx::Client.const_get("SPH_SORT_#{mode.to_s.upcase}"), mode == :relevance ? '' : 'sortby')
+          sphinx_safe_call { @sphinx.Query('query') }
+        end
+
+        it "should generate valid request for \"#{mode}\"" do
+          expected = sphinx_fixture("sort_#{mode}")
+          @sock.should_receive(:write).with(expected)
+          @sphinx.SetSortMode(mode.to_s, mode == :relevance ? '' : 'sortby')
+          sphinx_safe_call { @sphinx.Query('query') }
+        end
+
+        it "should generate valid request for :#{mode}" do
+          expected = sphinx_fixture("sort_#{mode}")
+          @sock.should_receive(:write).with(expected)
+          @sphinx.SetSortMode(mode, mode == :relevance ? '' : 'sortby')
+          sphinx_safe_call { @sphinx.Query('query') }
+        end
+      end
+    end
+
+    it 'should generate valid request with weights' do
+      expected = sphinx_fixture('weights')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetWeights([10, 20, 30, 40])
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with field weights' do
+      expected = sphinx_fixture('field_weights')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetFieldWeights({'field1' => 10, 'field2' => 20})
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with index weights' do
+      expected = sphinx_fixture('index_weights')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetIndexWeights({'index1' => 10, 'index2' => 20})
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with ID range' do
+      expected = sphinx_fixture('id_range')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetIDRange(10, 20)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with ID range and 64-bit ints' do
+      expected = sphinx_fixture('id_range64')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetIDRange(8589934591, 17179869183)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with values filter' do
+      expected = sphinx_fixture('filter')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetFilter('attr', [10, 20, 30])
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with two values filters' do
+      expected = sphinx_fixture('filters')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetFilter('attr2', [40, 50])
+      @sphinx.SetFilter('attr1', [10, 20, 30])
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with values filter excluded' do
+      expected = sphinx_fixture('filter_exclude')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetFilter('attr', [10, 20, 30], true)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with values filter range' do
+      expected = sphinx_fixture('filter_range')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetFilterRange('attr', 10, 20)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with two filter ranges' do
+      expected = sphinx_fixture('filter_ranges')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetFilterRange('attr2', 30, 40)
+      @sphinx.SetFilterRange('attr1', 10, 20)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with filter range excluded' do
+      expected = sphinx_fixture('filter_range_exclude')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetFilterRange('attr', 10, 20, true)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with signed int64-based filter range' do
+      expected = sphinx_fixture('filter_range_int64')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetFilterRange('attr1', -10, 20)
+      @sphinx.SetFilterRange('attr2', -1099511627770, 1099511627780)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with float filter range' do
+      expected = sphinx_fixture('filter_float_range')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetFilterFloatRange('attr', 10.5, 20.3)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with float filter excluded' do
+      expected = sphinx_fixture('filter_float_range_exclude')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetFilterFloatRange('attr', 10.5, 20.3, true)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with different filters' do
+      expected = sphinx_fixture('filters_different')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetFilterRange('attr1', 10, 20, true)
+      @sphinx.SetFilter('attr3', [30, 40, 50])
+      @sphinx.SetFilterRange('attr1', 60, 70)
+      @sphinx.SetFilter('attr2', [80, 90, 100], true)
+      @sphinx.SetFilterFloatRange('attr1', 60.8, 70.5)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with geographical anchor point' do
+      expected = sphinx_fixture('geo_anchor')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetGeoAnchor('attrlat', 'attrlong', 20.3, 40.7)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    describe 'with group by' do
+      [ :day, :week, :month, :year, :attr, :attrpair ].each do |groupby|
+        it "should generate valid request for SPH_GROUPBY_#{groupby.to_s.upcase}" do
+          expected = sphinx_fixture("group_by_#{groupby}")
+          @sock.should_receive(:write).with(expected)
+          @sphinx.SetGroupBy('attr', Sphinx::Client::const_get("SPH_GROUPBY_#{groupby.to_s.upcase}"))
+          sphinx_safe_call { @sphinx.Query('query') }
+        end
+
+        it "should generate valid request for \"#{groupby}\"" do
+          expected = sphinx_fixture("group_by_#{groupby}")
+          @sock.should_receive(:write).with(expected)
+          @sphinx.SetGroupBy('attr', groupby.to_s)
+          sphinx_safe_call { @sphinx.Query('query') }
+        end
+
+        it "should generate valid request for :#{groupby}" do
+          expected = sphinx_fixture("group_by_#{groupby}")
+          @sock.should_receive(:write).with(expected)
+          @sphinx.SetGroupBy('attr', groupby)
+          sphinx_safe_call { @sphinx.Query('query') }
+        end
+      end
+
+      it 'should generate valid request for SPH_GROUPBY_DAY with sort' do
+        expected = sphinx_fixture('group_by_day_sort')
+        @sock.should_receive(:write).with(expected)
+        @sphinx.SetGroupBy('attr', Sphinx::Client::SPH_GROUPBY_DAY, 'somesort')
+        sphinx_safe_call { @sphinx.Query('query') }
+      end
+
+      it 'should generate valid request with count-distinct attribute' do
+        expected = sphinx_fixture('group_distinct')
+        @sock.should_receive(:write).with(expected)
+        @sphinx.SetGroupBy('attr', Sphinx::Client::SPH_GROUPBY_DAY)
+        @sphinx.SetGroupDistinct('attr')
+        sphinx_safe_call { @sphinx.Query('query') }
+      end
+    end
+
+    it 'should generate valid request with retries count specified' do
+      expected = sphinx_fixture('retries')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetRetries(10)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request with retries count and delay specified' do
+      expected = sphinx_fixture('retries_delay')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetRetries(10, 20)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request for SetOverride' do
+      expected = sphinx_fixture('set_override')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetOverride('attr1', Sphinx::Client::SPH_ATTR_INTEGER, { 10 => 20 })
+      @sphinx.SetOverride('attr2', Sphinx::Client::SPH_ATTR_FLOAT, { 11 => 30.3 })
+      @sphinx.SetOverride('attr3', Sphinx::Client::SPH_ATTR_BIGINT, { 12 => 1099511627780 })
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request for SetSelect' do
+      expected = sphinx_fixture('select')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetSelect('attr1, attr2')
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+  end
+
+  context 'in RunQueries method' do
+    before(:each) do
+      @sphinx = sphinx_create_client
+    end
+
+    it 'should generate valid request for multiple queries' do
+      expected = sphinx_fixture('miltiple_queries')
+      @sock.should_receive(:write).with(expected)
+
+      @sphinx.SetRetries(10, 20)
+      @sphinx.AddQuery('test1')
+      @sphinx.SetGroupBy('attr', Sphinx::Client::SPH_GROUPBY_DAY)
+      @sphinx.AddQuery('test2')
+
+      sphinx_safe_call { @sphinx.RunQueries }
+    end
+  end
+
+  context 'in BuildExcerpts method' do
+    before :each do
+      @sphinx = sphinx_create_client
+    end
+
+    it 'should generate valid request with default parameters' do
+      expected = sphinx_fixture('excerpt_default')
+      @sock.should_receive(:write).with(expected)
+      sphinx_safe_call { @sphinx.BuildExcerpts(['10', '20'], 'index', 'word1 word2') }
+    end
+
+    it 'should generate valid request with custom parameters' do
+      expected = sphinx_fixture('excerpt_custom')
+      @sock.should_receive(:write).with(expected)
+      sphinx_safe_call do
+        @sphinx.BuildExcerpts(['10', '20'], 'index', 'word1 word2', { 'before_match'    => 'before',
+                                                                      'after_match'     => 'after',
+                                                                      'chunk_separator' => 'separator',
+                                                                      'limit'           => 10 })
+      end
+    end
+
+    it 'should generate valid request with custom parameters as symbols' do
+      expected = sphinx_fixture('excerpt_custom')
+      @sock.should_receive(:write).with(expected)
+      sphinx_safe_call do
+        @sphinx.BuildExcerpts(['10', '20'], 'index', 'word1 word2', { :before_match    => 'before',
+                                                                      :after_match     => 'after',
+                                                                      :chunk_separator => 'separator',
+                                                                      :limit           => 10 })
+      end
+    end
+
+    it 'should generate valid request with flags' do
+      expected = sphinx_fixture('excerpt_flags')
+      @sock.should_receive(:write).with(expected)
+      sphinx_safe_call do
+        @sphinx.BuildExcerpts(['10', '20'], 'index', 'word1 word2', { 'exact_phrase'   => true,
+                                                                      'single_passage' => true,
+                                                                      'use_boundaries' => true,
+                                                                      'weight_order'   => true,
+                                                                      'query_mode'     => true })
+      end
+    end
+
+    it 'should generate valid request with flags as symbols' do
+      expected = sphinx_fixture('excerpt_flags')
+      @sock.should_receive(:write).with(expected)
+      sphinx_safe_call do
+        @sphinx.BuildExcerpts(['10', '20'], 'index', 'word1 word2', { :exact_phrase   => true,
+                                                                      :single_passage => true,
+                                                                      :use_boundaries => true,
+                                                                      :weight_order   => true,
+                                                                      :query_mode     => true })
+      end
+    end
+  end
+
+  context 'in BuildKeywords method' do
+    before :each do
+      @sphinx = sphinx_create_client
+    end
+
+    it 'should generate valid request' do
+      expected = sphinx_fixture('keywords')
+      @sock.should_receive(:write).with(expected)
+      sphinx_safe_call { @sphinx.BuildKeywords('test', 'index', true) }
+    end
+  end
+
+  context 'in UpdateAttributes method' do
+    before :each do
+      @sphinx = sphinx_create_client
+    end
+
+    it 'should generate valid request' do
+      expected = sphinx_fixture('update_attributes')
+      @sock.should_receive(:write).with(expected)
+      sphinx_safe_call { @sphinx.UpdateAttributes('index', ['group'], { 123 => [456] }) }
+    end
+
+    it 'should generate valid request for MVA' do
+      expected = sphinx_fixture('update_attributes_mva')
+      @sock.should_receive(:write).with(expected)
+      sphinx_safe_call { @sphinx.UpdateAttributes('index', ['group', 'category'], { 123 => [ [456, 789], [1, 2, 3] ] }, true) }
+    end
+  end
+end