riddle 1.4.0 → 1.5.0

data/spec/unit/client_spec.rb

@@ -13,6 +13,12 @@ describe Riddle::Client do
   it "should default to port 9312" do
     Riddle::Client.new.port.should == 9312
   end
+
+  it "should accept an array of servers" do
+    servers = ["1.1.1.1", "2.2.2.2", "3.3.3.3"]
+    client = Riddle::Client.new(servers)
+    client.servers.should == servers
+  end
   
   it "should translate anchor arguments correctly" do
     client = Riddle::Client.new
@@ -32,182 +38,184 @@ describe Riddle::Client do
     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
+  describe 'query contents' do
+    it "should build a basic search message correctly" do
+      client = Riddle::Client.new
+      client.append_query "test "
+      client.queue.first.should == query_contents(:simple)
+    end
   
-  it "should build a message with a specified index correctly" do
-    client = Riddle::Client.new
-    client.append_query "test ", "edition"
-    client.queue.first.should == query_contents(:index)
-  end
+    it "should build a message 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 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 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 :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 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 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 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 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 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 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 index weights correctly" do
+      client = Riddle::Client.new
+      client.index_weights = {"people" => 101}
+      client.append_query "test "
+      client.queue.first.should == query_contents(:index_weights)
+    end
   
-  it "should build a message with field weights correctly" do
-    client = Riddle::Client.new
-    client.field_weights = {"city" => 101}
-    client.append_query "test "
-    client.queue.first.should == query_contents(:field_weights)
-  end
+    it "should build a message with field weights correctly" do
+      client = Riddle::Client.new
+      client.field_weights = {"city" => 101}
+      client.append_query "test "
+      client.queue.first.should == query_contents(:field_weights)
+    end
   
-  it "should build a message with a comment correctly" do
-    client = Riddle::Client.new
-    client.append_query "test ", "*", "commenting"
-    client.queue.first.should == query_contents(:comment)
-  end
+    it "should build a message with a comment correctly" do
+      client = Riddle::Client.new
+      client.append_query "test ", "*", "commenting"
+      client.queue.first.should == query_contents(:comment)
+    end
+  
+    if Riddle.loaded_version == '0.9.9' || Riddle.loaded_version == '1.10'
+      it "should build a message with overrides correctly" do
+        client = Riddle::Client.new
+        client.add_override("rating", :float, {1 => 10.0})
+        client.append_query "test "
+        client.queue.first.should == query_contents(:overrides)
+      end
+  
+      it "should build a message with selects correctly" do
+        client = Riddle::Client.new
+        client.select = "selecting"
+        client.append_query "test "
+        client.queue.first.should == query_contents(:select)
+      end
+    end
   
-  if Riddle.loaded_version == '0.9.9' || Riddle.loaded_version == '1.10'
-    it "should build a message with overrides correctly" do
+    it "should keep multiple messages in the queue" do
       client = Riddle::Client.new
-      client.add_override("rating", :float, {1 => 10.0})
+      client.weights = [100, 1]
+      client.append_query "test "
       client.append_query "test "
-      client.queue.first.should == query_contents(:overrides)
+      client.queue.length.should == 2
+      client.queue.each { |item| item.should == query_contents(:weights) }
     end
   
-    it "should build a message with selects correctly" do
+    it "should keep multiple messages in the queue with different params" do
       client = Riddle::Client.new
-      client.select = "selecting"
+      client.weights = [100, 1]
       client.append_query "test "
-      client.queue.first.should == query_contents(:select)
+      client.weights = []
+      client.append_query "test ", "edition"
+      client.queue.first.should == query_contents(:weights)
+      client.queue.last.should  == query_contents(:index)
     end
-  end
-  
-  it "should keep multiple messages in the queue" do
-    client = Riddle::Client.new
-    client.weights = [100, 1]
-    client.append_query "test "
-    client.append_query "test "
-    client.queue.length.should == 2
-    client.queue.each { |item| item.should == query_contents(:weights) }
-  end
   
-  it "should keep multiple messages in the queue with different params" do
-    client = Riddle::Client.new
-    client.weights = [100, 1]
-    client.append_query "test "
-    client.weights = []
-    client.append_query "test ", "edition"
-    client.queue.first.should == query_contents(:weights)
-    client.queue.last.should  == query_contents(:index)
-  end
-  
-  it "should build a basic update message correctly" do
-    client = Riddle::Client.new
-    client.send(
-      :update_message,
-      "people",
-      ["birthday"],
-      {1 => [191163600]}
-    ).should == query_contents(:update_simple)
-  end
+    it "should build a basic update message correctly" do
+      client = Riddle::Client.new
+      client.send(
+        :update_message,
+        "people",
+        ["birthday"],
+        {1 => [191163600]}
+      ).should == query_contents(:update_simple)
+    end
   
-  it "should build a keywords request without hits correctly" do
-    client = Riddle::Client.new
-    client.send(
-      :keywords_message,
-      "pat",
-      "people",
-      false
-    ).should == query_contents(:keywords_without_hits)
-  end
+    it "should build a keywords request without hits correctly" do
+      client = Riddle::Client.new
+      client.send(
+        :keywords_message,
+        "pat",
+        "people",
+        false
+      ).should == query_contents(:keywords_without_hits)
+    end
   
-  it "should build a keywords request with hits correctly" do
-    client = Riddle::Client.new
-    client.send(
-      :keywords_message,
-      "pat",
-      "people",
-      true
-    ).should == query_contents(:keywords_with_hits)
+    it "should build a keywords request with hits correctly" do
+      client = Riddle::Client.new
+      client.send(
+        :keywords_message,
+        "pat",
+        "people",
+        true
+      ).should == query_contents(:keywords_with_hits)
+    end
   end
   
   it "should timeout after a specified time" do
     client = Riddle::Client.new
-    client.port     = 3314
+    client.port     = 9314
     client.timeout  = 1
     
-    server = TCPServer.new "localhost", 3314
+    server = TCPServer.new "localhost", 9314
     
     lambda {
       client.send(:connect) { |socket| }
     }.should raise_error(Riddle::ConnectionError)
     
     server.close
-  end
+  end unless RUBY_PLATFORM == 'java' # JRuby doesn't like Timeout
 
   context "connection retrying" do
     it "should try fives time when connection refused" do
@@ -237,7 +245,7 @@ describe Riddle::Client do
       lambda {
         client.send(:connect) { |socket| }
       }.should raise_error(Riddle::ConnectionError)
-    end
+    end unless RUBY_PLATFORM == 'java' # JRuby doesn't like Timeout
 
     it "should try each of several server addresses after a connection refused" do
       client = Riddle::Client.new
@@ -255,6 +263,6 @@ describe Riddle::Client do
       lambda {
         client.send(:connect) { |socket| }
       }.should raise_error(Riddle::ConnectionError)
-    end
+    end unless RUBY_PLATFORM == 'java' # JRuby doesn't like Timeout
   end
 end

data/spec/unit/configuration/distributed_index_spec.rb

@@ -1,46 +1,46 @@
 require 'spec_helper'
 
 describe Riddle::Configuration::DistributedIndex do
-  it "should not be valid without any indexes" do
+  it "should not be valid without any indices" do
     index = Riddle::Configuration::DistributedIndex.new("dist1")
     index.should_not be_valid
   end
-  
-  it "should be valid with just local indexes" do
+
+  it "should be valid with just local indices" do
     index = Riddle::Configuration::DistributedIndex.new("dist1")
-    index.local_indexes << "local_one"
+    index.local_indices << "local_one"
     index.should be_valid
   end
-  
-  it "should be valid with just remote indexes" do
+
+  it "should be valid with just remote indices" do
     index = Riddle::Configuration::DistributedIndex.new("dist1")
-    index.remote_indexes << Riddle::Configuration::RemoteIndex.new("local", 3312, "remote_one")
+    index.remote_indices << Riddle::Configuration::RemoteIndex.new("local", 3312, "remote_one")
     index.should be_valid
   end
-  
+
   it "should be of type 'distributed'" do
     index = Riddle::Configuration::DistributedIndex.new("dist1")
     index.type.should == 'distributed'
   end
-  
+
   it "should raise a ConfigurationError if rendering when not valid" do
     index = Riddle::Configuration::DistributedIndex.new("dist1")
     lambda { index.render }.should raise_error(Riddle::Configuration::ConfigurationError)
   end
-  
+
   it "should render correctly if supplied settings are valid" do
     index = Riddle::Configuration::DistributedIndex.new("dist1")
-    
-    index.local_indexes << "test1" << "test1stemmed"
-    index.remote_indexes <<
+
+    index.local_indices << "test1" << "test1stemmed"
+    index.remote_indices <<
       Riddle::Configuration::RemoteIndex.new("localhost", 3313, "remote1") <<
       Riddle::Configuration::RemoteIndex.new("localhost", 3314, "remote2") <<
       Riddle::Configuration::RemoteIndex.new("localhost", 3314, "remote3")
     index.agent_blackhole << "testbox:3312:testindex1,testindex2"
-    
+
     index.agent_connect_timeout = 1000
     index.agent_query_timeout   = 3000
-    
+
     index.render.should == <<-DISTINDEX
 index dist1
 {

data/spec/unit/configuration/searchd_spec.rb

@@ -54,12 +54,37 @@ describe Riddle::Configuration::Searchd do
       searchd.should respond_to("#{setting}=".to_sym)
     end
   end
-  
+
+  it "should support setting listen to a port number" do
+    searchd = Riddle::Configuration::Searchd.new
+    searchd.port = 3312
+    searchd.pid_file = "file.pid"
+    searchd.listen = 3312
+
+    if Riddle.loaded_version.to_f >= 0.9
+      searchd.render.should == <<-SEARCHD
+searchd
+{
+  listen = 3312
+  pid_file = file.pid
+}
+      SEARCHD
+    else
+      searchd.render.should == <<-SEARCHD
+searchd
+{
+  port = 3312
+  pid_file = file.pid
+}
+      SEARCHD
+    end
+  end
+
   it "should render a correct configuration with valid settings" do
     searchd = Riddle::Configuration::Searchd.new
     searchd.port      = 3312
     searchd.pid_file  = "file.pid"
-    
+
     if Riddle.loaded_version.to_f >= 0.9
       searchd.render.should == <<-SEARCHD
 searchd
@@ -78,7 +103,7 @@ searchd
       SEARCHD
     end
   end
-  
+
   it "should render with a client key if one is provided" do
     searchd = Riddle::Configuration::Searchd.new
     searchd.port       = 3312