riddle 0.9.8.1112

data/spec/fixtures/sql/structure.sql

@@ -0,0 +1,16 @@
+DROP TABLE `people`;
+
+CREATE TABLE `people` (
+  `id` int(11) NOT NULL auto_increment,
+  `first_name` varchar(50) NOT NULL,
+  `middle_initial` varchar(10) NOT NULL,
+  `last_name` varchar(50) NOT NULL,
+  `gender` varchar(10) NOT NULL,
+  `street_address` varchar(200) NOT NULL,
+  `city` varchar(100) NOT NULL,
+  `state` varchar(100) NOT NULL,
+  `postcode` varchar(10) NOT NULL,
+  `email` varchar(100) NOT NULL,
+  `birthday` datetime NOT NULL,
+  PRIMARY KEY  (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;

data/spec/functional/excerpt_spec.rb

@@ -0,0 +1,102 @@
+require 'spec/spec_helper'
+
+describe "Sphinx Excepts" do
+  before :each do
+    @client = Riddle::Client.new("localhost", 3313)
+  end
+  
+  it "should highlight a single word multiple times in a document" do
+    @client.excerpts(
+      :index  => "people",
+      :words  => "Mary",
+      :docs   => ["Mary, Mary, quite contrary."]
+    ).should == [
+      '<span class="match">Mary</span>, <span class="match">Mary</span>, quite contrary.'
+    ]
+  end
+  
+  it "should use specified word markers" do
+    @client.excerpts(
+      :index        => "people",
+      :words        => "Mary",
+      :docs         => ["Mary, Mary, quite contrary."],
+      :before_match => "<em>",
+      :after_match  => "</em>"
+    ).should == [
+      "<em>Mary</em>, <em>Mary</em>, quite contrary."
+    ]
+  end
+  
+  it "should separate matches that are far apart by an ellipsis by default" do
+    @client.excerpts(
+      :index        => "people",
+      :words        => "Pat",
+      :docs         => [
+        <<-SENTENCE
+This is a really long sentence written by Pat. It has to be over 256
+characters long, between keywords. But what is the keyword? Well, I 
+can't tell you just yet... wait patiently until we've hit the 256 mark.
+It'll take a bit longer than you think. We're probably just hitting the
+200 mark at this point. But I think we've now arrived - so I can tell
+you what the keyword is. I bet you're really interested in finding out,
+yeah? Excerpts are particularly riveting. This keyword, however, is
+not. It's just my name: Pat.
+        SENTENCE
+        ],
+      :before_match => "<em>",
+      :after_match  => "</em>"
+    ).should == [
+      <<-SENTENCE
+This is a really long sentence written by <em>Pat</em>. It has to be over 256
+characters long, between keywords. But what is the keyword?  &#8230;  interested in finding out,
+yeah? Excerpts are particularly riveting. This keyword, however, is
+not. It's just my name: <em>Pat</em>.
+      SENTENCE
+    ]
+  end
+  
+  it "should use the provided separator" do
+    @client.excerpts(
+      :index           => "people",
+      :words           => "Pat",
+      :docs            => [
+        <<-SENTENCE
+This is a really long sentence written by Pat. It has to be over 256
+characters long, between keywords. But what is the keyword? Well, I 
+can't tell you just yet... wait patiently until we've hit the 256 mark.
+It'll take a bit longer than you think. We're probably just hitting the
+200 mark at this point. But I think we've now arrived - so I can tell
+you what the keyword is. I bet you're really interested in finding out,
+yeah? Excerpts are particularly riveting. This keyword, however, is
+not. It's just my name: Pat.
+        SENTENCE
+        ],
+      :before_match    => "<em>",
+      :after_match     => "</em>",
+      :chunk_separator => " --- "
+    ).should == [
+      <<-SENTENCE
+This is a really long sentence written by <em>Pat</em>. It has to be over 256
+characters long, between keywords. But what is the keyword?  ---  interested in finding out,
+yeah? Excerpts are particularly riveting. This keyword, however, is
+not. It's just my name: <em>Pat</em>.
+      SENTENCE
+    ]
+  end
+  
+  it "should return multiple results for multiple documents" do
+     @client.excerpts(
+        :index        => "people",
+        :words        => "Mary",
+        :docs         => [
+          "Mary, Mary, quite contrary.",
+          "The epithet \"Bloody Mary\" is associated with a number of historical and fictional women, most notably Queen Mary I of England"
+        ],
+        :before_match => "<em>",
+        :after_match  => "</em>"
+      ).should == [
+        "<em>Mary</em>, <em>Mary</em>, quite contrary.",
+        "The epithet \"Bloody <em>Mary</em>\" is associated with a number of historical and fictional women, most notably Queen <em>Mary</em> I of England"
+      ]
+  end
+end

data/spec/functional/search_spec.rb

@@ -0,0 +1,69 @@
+require 'spec/spec_helper'
+
+describe "Sphinx Searches" do
+  before :each do
+    @client = Riddle::Client.new("localhost", 3313)
+  end
+  
+  it "should return a single hash if a single query" do
+    @client.query("smith").should be_kind_of(Hash)
+  end
+  
+  it "should return an array of hashs if multiple queries are run" do
+    @client.append_query "smith"
+    @client.append_query "jones"
+    results = @client.run
+    results.should be_kind_of(Array)
+    results.each { |result| result.should be_kind_of(Hash) }
+  end
+  
+  it "should return an array of matches" do
+    matches = @client.query("smith")[:matches]
+    matches.should be_kind_of(Array)
+    matches.each { |match| match.should be_kind_of(Hash) }
+  end
+  
+  it "should return an array of string fields" do
+    fields = @client.query("smith")[:fields]
+    fields.should be_kind_of(Array)
+    fields.each { |field| field.should be_kind_of(String) }
+  end
+  
+  it "should return an array of attribute names" do
+    attributes = @client.query("smith")[:attribute_names]
+    attributes.should be_kind_of(Array)
+    attributes.each { |a| a.should be_kind_of(String) }
+  end
+  
+  it "should return a hash of attributes" do
+    attributes = @client.query("smith")[:attributes]
+    attributes.should be_kind_of(Hash)
+    attributes.each do |key,value|
+      key.should be_kind_of(String)
+      value.should be_kind_of(Integer)
+    end
+  end
+  
+  it "should return the total number of results returned" do
+    @client.query("smith")[:total].should be_kind_of(Integer)
+  end
+  
+  it "should return the total number of results available" do
+    @client.query("smith")[:total_found].should be_kind_of(Integer)
+  end
+  
+  it "should return the time taken for the query as a float" do
+    @client.query("smith")[:time].should be_kind_of(Float)
+  end
+  
+  it "should return a hash of the words from the query, with the number of documents and the number of hits" do
+    words = @client.query("smith victoria")[:words]
+    words.should be_kind_of(Hash)
+    words.each do |word,hash|
+      word.should be_kind_of(String)
+      hash.should be_kind_of(Hash)
+      hash[:docs].should be_kind_of(Integer)
+      hash[:hits].should be_kind_of(Integer)
+    end
+  end
+end

data/spec/functional/update_spec.rb

@@ -0,0 +1,41 @@
+require 'spec/spec_helper'
+
+describe "Sphinx Updates" do
+  before :each do
+    @client = Riddle::Client.new("localhost", 3313)
+  end
+  
+  it "should update a single record appropriately" do
+    # check existing birthday
+    result = @client.query("Ellie K Ford")
+    result[:matches].should_not be_empty
+    result[:matches].length.should == 1
+    ellie = result[:matches].first
+    ellie[:attributes]["birthday"].should == Time.local(1970, 1, 23).to_i
+    
+    # make Ellie younger by 6 years
+    @client.update("people", ["birthday"], {ellie[:doc] => [Time.local(1976, 1, 23).to_i]})
+    
+    # check attribute's value
+    result = @client.query("Ellie K Ford")
+    result[:matches].should_not be_empty
+    result[:matches].length.should == 1
+    ellie = result[:matches].first
+    ellie[:attributes]["birthday"].should == Time.local(1976, 1, 23).to_i
+  end
+  
+  it "should update multiple records appropriately" do
+    result = @client.query("Steele")
+    pairs = {}
+    result[:matches].each do |match|
+      pairs[match[:doc]] = [match[:attributes]["birthday"] + (365*24*60*60)]
+    end
+    
+    @client.update "people", ["birthday"], pairs
+    
+    result = @client.query("Steele")
+    result[:matches].each do |match|
+      match[:attributes]["birthday"].should == pairs[match[:doc]].first
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'riddle'
+require 'spec/sphinx_helper'
+
+Spec::Runner.configure do |config|
+  sphinx = SphinxHelper.new
+  sphinx.setup_mysql
+  sphinx.generate_configuration
+  sphinx.index
+  
+  config.before :all do
+    `php -f spec/fixtures/data_generator.php`
+    sphinx.start
+  end
+  
+  # config.before :each do
+  #   sphinx.reset
+  # end
+  
+  config.after :all do
+    sphinx.stop
+  end
+end
+
+def query_contents(key)
+  open("spec/fixtures/data/#{key.to_s}.bin") { |f| f.read }
+end

data/spec/sphinx_helper.rb

@@ -0,0 +1,92 @@
+require 'mysql'
+require 'erb'
+require 'yaml'
+
+class SphinxHelper
+  attr_accessor :host, :username, :password
+  attr_reader   :path
+  
+  def initialize
+    @host     = "localhost"
+    @username = "anonymous"
+    @password = ""
+
+    if File.exist?("spec/fixtures/sql/conf.yml")
+      config    = YAML.load(File.open("spec/fixtures/sql/conf.yml"))
+      @host     = config["host"]
+      @username = config["username"]
+      @password = config["password"]
+    end
+    
+    @path = File.expand_path(File.dirname(__FILE__))
+  end
+  
+  def setup_mysql
+    server = Mysql.new @host, @username, @password
+
+    unless server.list_dbs.include?("riddle_sphinx_spec")
+      server.create_db "riddle_sphinx_spec"
+    end
+
+    server.query "USE riddle_sphinx_spec;"
+    
+    structure = File.open("spec/fixtures/sql/structure.sql") { |f| f.read }
+    # Block ensures multiple statements can be run
+    server.query(structure) { }
+    data      = File.open("spec/fixtures/sql/data.sql") { |f|
+      while line = f.gets
+        server.query line
+      end
+    }
+
+    server.close
+  end
+  
+  def reset
+    setup_mysql
+    index
+  end
+  
+  def generate_configuration
+    template = File.open("spec/fixtures/sphinx/configuration.erb") { |f| f.read }
+    File.open("spec/fixtures/sphinx/spec.conf", "w") { |f|
+      f.puts ERB.new(template).result(binding)
+    }
+  end
+  
+  def index
+    cmd = "indexer --config #{@path}/fixtures/sphinx/spec.conf --all"
+    cmd << " --rotate" if running?
+    `#{cmd}`
+  end
+  
+  def start
+    return if running?
+
+    cmd = "searchd --config #{@path}/fixtures/sphinx/spec.conf"
+    `#{cmd}`
+
+    sleep(1)
+
+    unless running?
+      puts "Failed to start searchd daemon. Check fixtures/sphinx/searchd.log."
+    end
+  end
+  
+  def stop
+    return unless running?
+    `kill #{pid}`
+  end
+  
+  def pid
+    if File.exists?("#{@path}/fixtures/sphinx/searchd.pid")
+      `cat #{@path}/fixtures/sphinx/searchd.pid`[/\d+/]
+    else
+      nil
+    end
+  end
+
+  def running?
+    pid && `ps #{pid} | wc -l`.to_i > 1
+  end
+end

data/spec/unit/client_spec.rb

@@ -0,0 +1,154 @@
+require 'spec/spec_helper'
+
+describe Riddle::Client do
+  it "should have the same keys for both commands and versions" do
+    Riddle::Client::Commands.keys.should == Riddle::Client::Versions.keys
+  end
+  
+  it "should default to localhost as the server" do
+    Riddle::Client.new.server.should == "localhost"
+  end
+  
+  it "should default to port 3312" do
+    Riddle::Client.new.port.should == 3312
+  end
+  
+  it "should translate anchor arguments correctly" do
+    client = Riddle::Client.new
+    client.set_anchor "latitude", 10.0, "longitude", 95.0
+    client.anchor.should == {
+      :latitude_attribute   => "latitude",
+      :latitude             => 10.0,
+      :longitude_attribute  => "longitude",
+      :longitude            => 95.0
+    }
+  end
+  
+  it "should add queries to the queue" do
+    client = Riddle::Client.new
+    client.queue.should be_empty
+    client.append_query "spec"
+    client.queue.should_not be_empty
+  end
+  
+  it "should build a basic search message correctly" do
+    client = Riddle::Client.new
+    client.append_query "test "
+    client.queue.first.should == query_contents(:simple)
+  end
+  
+  it "should build a message with a specified index correctly" do
+    client = Riddle::Client.new
+    client.append_query "test ", "edition"
+    client.queue.first.should == query_contents(:index)
+  end
+  
+  it "should build a message using match mode :any correctly" do
+    client = Riddle::Client.new
+    client.match_mode = :any
+    client.append_query "test this "
+    client.queue.first.should == query_contents(:any)
+  end
+  
+  it "should build a message using sort by correctly" do
+    client = Riddle::Client.new
+    client.sort_by = 'id'
+    client.sort_mode = :extended
+    client.append_query "testing "
+    client.queue.first.should == query_contents(:sort)
+  end
+  
+  it "should build a message using match mode :boolean correctly" do
+    client = Riddle::Client.new
+    client.match_mode = :boolean
+    client.append_query "test "
+    client.queue.first.should == query_contents(:boolean)
+  end
+  
+  it "should build a message using match mode :phrase correctly" do
+    client = Riddle::Client.new
+    client.match_mode = :phrase
+    client.append_query "testing this "
+    client.queue.first.should == query_contents(:phrase)
+  end
+  
+  it "should build a message with a filter correctly" do
+    client = Riddle::Client.new
+    client.filters << Riddle::Client::Filter.new("id", [10, 100, 1000])
+    client.append_query "test "
+    client.queue.first.should == query_contents(:filter)
+  end
+  
+  it "should build a message with group values correctly" do
+    client = Riddle::Client.new
+    client.group_by       = "id"
+    client.group_function = :attr
+    client.group_clause   = "id"
+    client.append_query "test "
+    client.queue.first.should == query_contents(:group)
+  end
+  
+  it "should build a message with group distinct value correctly" do
+    client = Riddle::Client.new
+    client.group_distinct = "id"
+    client.append_query "test "
+    client.queue.first.should == query_contents(:distinct)
+  end
+  
+  it "should build a message with weights correctly" do
+    client = Riddle::Client.new
+    client.weights = [100, 1]
+    client.append_query "test "
+    client.queue.first.should == query_contents(:weights)
+  end
+  
+  it "should build a message with an anchor correctly" do
+    client = Riddle::Client.new
+    client.set_anchor "latitude", 10.0, "longitude", 95.0
+    client.append_query "test "
+    client.queue.first.should == query_contents(:anchor)
+  end
+  
+  it "should build a message with index weights correctly" do
+    client = Riddle::Client.new
+    client.index_weights = {"people" => 101}
+    client.append_query "test "
+    client.queue.first.should == query_contents(:index_weights)
+  end
+  
+  it "should build a message with field weights correctly" do
+    client = Riddle::Client.new
+    client.field_weights = {"city" => 101}
+    client.append_query "test "
+    client.queue.first.should == query_contents(:field_weights)
+  end
+  
+  it "should keep multiple messages in the queue" do
+    client = Riddle::Client.new
+    client.weights = [100, 1]
+    client.append_query "test "
+    client.append_query "test "
+    client.queue.length.should == 2
+    client.queue.each { |item| item.should == query_contents(:weights) }
+  end
+  
+  it "should keep multiple messages in the queue with different params" do
+    client = Riddle::Client.new
+    client.weights = [100, 1]
+    client.append_query "test "
+    client.weights = []
+    client.append_query "test ", "edition"
+    client.queue.first.should == query_contents(:weights)
+    client.queue.last.should  == query_contents(:index)
+  end
+  
+  it "should build a basic update message correctly" do
+    client = Riddle::Client.new
+    client.send(
+      :update_message,
+      "people",
+      ["birthday"],
+      {1 => [191163600]}
+    ).should == query_contents(:update_simple)
+  end
+end