ninjudd-model_set 0.9.2

data/vendor/sphinx_client/lib/sphinx/request.rb

@@ -0,0 +1,50 @@
+module Sphinx
+  # Pack ints, floats, strings, and arrays to internal representation
+  # needed by Sphinx search engine.
+  class Request
+    # Initialize new request.
+    def initialize
+      @request = ''
+    end
+    
+    # Put int(s) to request.
+    def put_int(*ints)
+      ints.each { |i| @request << [i].pack('N') }
+    end
+
+    # Put 64-bit int(s) to request.
+    def put_int64(*ints)
+      ints.each { |i| @request << [i].pack('q').reverse }#[i >> 32, i & ((1 << 32) - 1)].pack('NN') }
+    end
+
+    # Put string(s) to request (first length, then the string itself).
+    def put_string(*strings)
+      strings.each { |s| @request << [s.length].pack('N') + s }
+    end
+    
+    # Put float(s) to request.
+    def put_float(*floats)
+      floats.each do |f|
+        t1 = [f].pack('f') # machine order
+        t2 = t1.unpack('L*').first # int in machine order
+        @request << [t2].pack('N')
+      end
+    end
+    
+    # Put array of ints to request (first length, then the array itself)
+    def put_int_array(arr)
+      put_int arr.length, *arr
+    end
+
+    # Put array of 64-bit ints to request (first length, then the array itself)
+    def put_int64_array(arr)
+      put_int arr.length
+      put_int64(*arr)
+    end
+    
+    # Returns the entire message
+    def to_s
+      @request
+    end
+  end
+end

data/vendor/sphinx_client/lib/sphinx/response.rb

@@ -0,0 +1,69 @@
+module Sphinx
+  # Unpack internal Sphinx representation of ints, floats, strings, and arrays.
+  # needed by Sphinx search engine.
+  class Response
+    # Initialize new request.
+    def initialize(response)
+      @response = response
+      @position = 0
+      @size = response.length
+    end
+    
+    # Gets current stream position.
+    def position
+      @position
+    end
+    
+    # Gets response size.
+    def size
+      @size
+    end
+    
+    # Returns <tt>true</tt> when response stream is out.
+    def eof?
+      @position >= @size
+    end
+
+    # Get int from stream.
+    def get_int
+      raise EOFError if @position + 4 > @size
+      value = @response[@position, 4].unpack('N*').first
+      @position += 4
+      return value
+    end
+
+    # Get 64-bit int from stream.
+    def get_int64
+      raise EOFError if @position + 8 > @size
+      hi, lo = @response[@position, 8].unpack('N*N*')
+      @position += 8
+      return (hi << 32) + lo
+    end
+
+    # Get array of <tt>count</tt> ints from stream.
+    def get_ints(count)
+      length = 4 * count
+      raise EOFError if @position + length > @size
+      values = @response[@position, length].unpack('N*' * count)
+      @position += length
+      return values
+    end
+    
+    # Get string from stream.
+    def get_string
+      length = get_int
+      raise EOFError if @position + length > @size
+      value = length > 0 ? @response[@position, length] : ''
+      @position += length
+      return value
+    end
+    
+    # Get float from stream.
+    def get_float
+      raise EOFError if @position + 4 > @size
+      uval = @response[@position, 4].unpack('N*').first;
+      @position += 4
+      return ([uval].pack('L')).unpack('f*').first
+    end
+  end
+end

data/vendor/sphinx_client/spec/client_response_spec.rb

@@ -0,0 +1,112 @@
+require File.dirname(__FILE__) + '/../init'
+
+# To execute these tests you need to execute sphinx_test.sql and configure sphinx using sphinx.conf
+# (both files are placed under sphinx directory)
+context 'The SphinxApi connected to Sphinx' do
+  setup do
+    @sphinx = Sphinx::Client.new
+  end
+  
+  specify 'should parse response in Query method' do
+    result = @sphinx.Query('wifi', 'test1')
+    validate_results_wifi(result)
+  end
+
+  specify 'should process 64-bit keys in Query method' do
+    result = @sphinx.Query('wifi', 'test2')
+    result['total_found'].should == 3
+    result['matches'].length.should == 3
+    result['matches'][0]['id'].should == 4294967298
+    result['matches'][1]['id'].should == 4294967299
+    result['matches'][2]['id'].should == 4294967297
+  end
+  
+  specify 'should parse batch-query responce in RunQueries method' do
+    @sphinx.AddQuery('wifi', 'test1')
+    @sphinx.AddQuery('gprs', 'test1')
+    results = @sphinx.RunQueries
+    results.should be_an_instance_of(Array)
+    results.length.should == 2
+    validate_results_wifi(results[0])
+  end
+  
+  specify 'should parse response in BuildExcerpts method' do
+    result = @sphinx.BuildExcerpts(['what the world', 'London is the capital of Great Britain'], 'test1', 'the')
+    result.should == ['what <b>the</b> world', 'London is <b>the</b> capital of Great Britain']
+  end
+
+  specify 'should parse response in BuildKeywords method' do
+    result = @sphinx.BuildKeywords('wifi gprs', 'test1', true)
+    result.should == [
+      { 'normalized' => 'wifi', 'tokenized' => 'wifi', 'hits' => 6, 'docs' => 3 },
+      { 'normalized' => 'gprs', 'tokenized' => 'gprs', 'hits' => 1, 'docs' => 1 }
+    ]
+  end
+
+  specify 'should parse response in UpdateAttributes method' do
+    @sphinx.UpdateAttributes('test1', ['group_id'], { 2 => [1] }).should == 1
+    result = @sphinx.Query('wifi', 'test1')
+    result['matches'][0]['attrs']['group_id'].should == 1
+    @sphinx.UpdateAttributes('test1', ['group_id'], { 2 => [2] }).should == 1
+    result = @sphinx.Query('wifi', 'test1')
+    result['matches'][0]['attrs']['group_id'].should == 2
+  end
+
+  specify 'should parse response in UpdateAttributes method with MVA' do
+    @sphinx.UpdateAttributes('test1', ['tags'], { 2 => [[1, 2, 3, 4, 5, 6, 7, 8, 9]] }, true).should == 1
+    result = @sphinx.Query('wifi', 'test1')
+    result['matches'][0]['attrs']['tags'].should == [1, 2, 3, 4, 5, 6, 7, 8, 9]
+    @sphinx.UpdateAttributes('test1', ['tags'], { 2 => [[5, 6, 7, 8]] }, true).should == 1
+    result = @sphinx.Query('wifi', 'test1')
+    result['matches'][0]['attrs']['tags'].should == [5, 6, 7, 8]
+  end
+  
+  specify 'should process errors in Query method' do
+  	@sphinx.Query('wifi', 'fakeindex').should be_false
+  	@sphinx.GetLastError.length.should_not == 0
+  end
+
+  specify 'should process errors in RunQueries method' do
+  	@sphinx.AddQuery('wifi', 'fakeindex')
+  	r = @sphinx.RunQueries
+  	r[0]['error'].length.should_not == 0
+  end
+  
+  def validate_results_wifi(result)
+    result['total_found'].should == 3
+    result['matches'].length.should == 3
+    result['time'].should_not be_nil
+    result['attrs'].should == {
+      'group_id' => Sphinx::Client::SPH_ATTR_INTEGER,
+      'created_at' => Sphinx::Client::SPH_ATTR_TIMESTAMP,
+      'rating' => Sphinx::Client::SPH_ATTR_FLOAT,
+      'tags' => Sphinx::Client::SPH_ATTR_MULTI | Sphinx::Client::SPH_ATTR_INTEGER
+    }
+    result['fields'].should == [ 'name', 'description' ]
+    result['total'].should == 3
+    result['matches'].should be_an_instance_of(Array)
+    
+    result['matches'][0]['id'].should == 2
+    result['matches'][0]['weight'].should == 2
+    result['matches'][0]['attrs']['group_id'].should == 2
+    result['matches'][0]['attrs']['created_at'].should == 1175658555
+    result['matches'][0]['attrs']['tags'].should == [5, 6, 7, 8]
+    ('%0.2f' % result['matches'][0]['attrs']['rating']).should == '54.85'
+    
+    result['matches'][1]['id'].should == 3
+    result['matches'][1]['weight'].should == 2
+    result['matches'][1]['attrs']['group_id'].should == 1
+    result['matches'][1]['attrs']['created_at'].should == 1175658647
+    result['matches'][1]['attrs']['tags'].should == [1, 7, 9, 10]
+    ('%0.2f' % result['matches'][1]['attrs']['rating']).should == '16.25'
+
+    result['matches'][2]['id'].should == 1
+    result['matches'][2]['weight'].should == 1
+    result['matches'][2]['attrs']['group_id'].should == 1
+    result['matches'][2]['attrs']['created_at'].should == 1175658490
+    result['matches'][2]['attrs']['tags'].should == [1, 2, 3, 4]
+    ('%0.2f' % result['matches'][2]['attrs']['rating']).should == '13.32'
+    
+    result['words'].should == { 'wifi' => { 'hits' => 6, 'docs' => 3 } }
+  end
+end

data/vendor/sphinx_client/spec/client_spec.rb

@@ -0,0 +1,469 @@
+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(: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'
+  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 ].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 }) 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