client_spec.rb

做搜索的

require File.dirname(__FILE__) + '/../init'

module SphinxFixtureHelper
  def sphinx_fixture(name)
    `php #{File.dirname(__FILE__)}/fixtures/#{name}.php`
  end
end

describe 'The Connect method of SphinxApi' 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 SphinxApi' 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 SphinxApi' 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('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

  it 'should generate valid request with match SPH_MATCH_ALL' do
    expected = sphinx_fixture('match_all')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetMatchMode(Sphinx::Client::SPH_MATCH_ALL)
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with match SPH_MATCH_ANY' do
    expected = sphinx_fixture('match_any')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetMatchMode(Sphinx::Client::SPH_MATCH_ANY)
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with match SPH_MATCH_PHRASE' do
    expected = sphinx_fixture('match_phrase')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetMatchMode(Sphinx::Client::SPH_MATCH_PHRASE)
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with match SPH_MATCH_BOOLEAN' do
    expected = sphinx_fixture('match_boolean')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetMatchMode(Sphinx::Client::SPH_MATCH_BOOLEAN)
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with match SPH_MATCH_EXTENDED' do
    expected = sphinx_fixture('match_extended')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetMatchMode(Sphinx::Client::SPH_MATCH_EXTENDED)
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with match SPH_MATCH_FULLSCAN' do
    expected = sphinx_fixture('match_fullscan')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetMatchMode(Sphinx::Client::SPH_MATCH_FULLSCAN)
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with match SPH_MATCH_EXTENDED2' do
    expected = sphinx_fixture('match_extended2')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetMatchMode(Sphinx::Client::SPH_MATCH_EXTENDED2)
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with ranking mode SPH_RANK_PROXIMITY_BM25' do
    expected = sphinx_fixture('ranking_proximity_bm25')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetRankingMode(Sphinx::Client::SPH_RANK_PROXIMITY_BM25)
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with ranking mode SPH_RANK_BM25' do
    expected = sphinx_fixture('ranking_bm25')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetRankingMode(Sphinx::Client::SPH_RANK_BM25)
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with ranking mode SPH_RANK_NONE' do
    expected = sphinx_fixture('ranking_none')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetRankingMode(Sphinx::Client::SPH_RANK_NONE)
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with ranking mode SPH_RANK_WORDCOUNT' do
    expected = sphinx_fixture('ranking_wordcount')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetRankingMode(Sphinx::Client::SPH_RANK_WORDCOUNT)
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with sort mode SPH_SORT_RELEVANCE' do
    expected = sphinx_fixture('sort_relevance')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetSortMode(Sphinx::Client::SPH_SORT_RELEVANCE)
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with sort mode SPH_SORT_ATTR_DESC' do
    expected = sphinx_fixture('sort_attr_desc')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetSortMode(Sphinx::Client::SPH_SORT_ATTR_DESC, 'sortby')
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with sort mode SPH_SORT_ATTR_ASC' do
    expected = sphinx_fixture('sort_attr_asc')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetSortMode(Sphinx::Client::SPH_SORT_ATTR_ASC, 'sortby')
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with sort mode SPH_SORT_TIME_SEGMENTS' do
    expected = sphinx_fixture('sort_time_segments')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetSortMode(Sphinx::Client::SPH_SORT_TIME_SEGMENTS, 'sortby')
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with sort mode SPH_SORT_EXTENDED' do
    expected = sphinx_fixture('sort_extended')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetSortMode(Sphinx::Client::SPH_SORT_EXTENDED, 'sortby')
    @sphinx.Query('query') rescue nil?
  end


  it 'should generate valid request with sort mode SPH_SORT_EXPR' do
    expected = sphinx_fixture('sort_EXPR')
    @sock.should_receive(:send).with(expected, 0)
    @sphinx.SetSortMode(Sphinx::Client::SPH_SORT_EXPR, 'sortby')
    @sphinx.Query('query') rescue nil?
  end

  it 'should generate valid request with weights' do
    expected = sphinx_fixture('weights')