rsolr 0.12.0 → 1.0.3

data/spec/api/client_spec.rb

@@ -0,0 +1,216 @@
+require 'spec_helper'
+describe "RSolr::Client" do
+  
+  module ClientHelper
+    def client
+      @client ||= (
+        connection = RSolr::Connection.new
+        RSolr::Client.new connection, :url => "http://localhost:9999/solr"
+      )
+    end
+  end
+  
+  context "initialize" do
+    it "should accept whatevs and set it as the @connection" do
+      RSolr::Client.new(:whatevs).connection.should == :whatevs
+    end
+  end
+  
+  context "send_and_receive" do
+    include ClientHelper
+    it "should forward these method calls the #connection object" do
+      [:get, :post, :head].each do |meth|
+        client.connection.should_receive(:execute).
+            and_return({:status => 200, :body => "{}", :headers => {}})
+        client.send_and_receive '', :method => meth, :params => {}, :data => nil, :headers => {}
+      end
+    end
+  end
+
+  context "post" do
+    include ClientHelper
+    it "should pass the expected params to the connection's #execute method" do
+      request_opts = {:data => "the data", :method=>:post, :headers => {"Content-Type" => "text/plain"}}
+      client.connection.should_receive(:execute).
+        with(client, hash_including(request_opts)).
+        and_return(
+          :body => "",
+          :status => 200,
+          :headers => {"Content-Type"=>"text/plain"}
+        )
+      client.post "update", request_opts
+    end
+  end
+  
+  context "xml" do
+    include ClientHelper
+    it "should return an instance of RSolr::Xml::Generator" do
+      client.xml.should be_a RSolr::Xml::Generator
+    end
+  end
+  
+  context "add" do
+    include ClientHelper
+    it "should send xml to the connection's #post method" do
+      client.connection.should_receive(:execute).
+        with(
+          client, hash_including({
+            :path => "update",
+            :headers => {"Content-Type"=>"text/xml"},
+            :method => :post,
+            :data => "<xml/>"
+          })
+        ).
+          and_return(
+            :body => "",
+            :status => 200,
+            :headers => {"Content-Type"=>"text/xml"}
+          )
+      client.xml.should_receive(:add).
+        with({:id=>1}, {:commitWith=>10}).
+          and_return("<xml/>")
+      client.add({:id=>1}, :add_attributes => {:commitWith=>10})
+    end
+  end
+  
+  context "update" do
+    include ClientHelper
+    it "should send data to the connection's #post method" do
+      client.connection.should_receive(:execute).
+        with(
+          client, hash_including({
+            :path => "update",
+            :headers => {"Content-Type"=>"text/xml"},
+            :method => :post,
+            :data => "<optimize/>"
+          })
+        ).
+          and_return(
+            :body => "",
+            :status => 200,
+            :headers => {"Content-Type"=>"text/xml"}
+          )
+      client.update(:data => "<optimize/>")
+    end
+  end
+  
+  context "post based helper methods:" do
+    include ClientHelper
+    [:commit, :optimize, :rollback].each do |meth|
+      it "should send a #{meth} message to the connection's #post method" do
+        client.connection.should_receive(:execute).
+          with(
+            client, hash_including({
+              :path => "update",
+              :headers => {"Content-Type"=>"text/xml"},
+              :method => :post,
+              :data => "<?xml version=\"1.0\" encoding=\"UTF-8\"?><#{meth}/>"
+            })
+          ).
+            and_return(
+              :body => "",
+              :status => 200,
+              :headers => {"Content-Type"=>"text/xml"}
+            )
+        client.send meth
+      end
+    end
+  end
+  
+  context "delete_by_id" do
+    include ClientHelper
+    it "should send data to the connection's #post method" do
+      client.connection.should_receive(:execute).
+        with(
+          client, hash_including({
+            :path => "update",
+            :headers => {"Content-Type"=>"text/xml"},
+            :method => :post,
+            :data => "<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><id>1</id></delete>"
+          })
+        ).
+          and_return(
+            :body => "",
+            :status => 200,
+            :headers => {"Content-Type"=>"text/xml"}
+          )
+      client.delete_by_id 1
+    end
+  end
+  
+  context "delete_by_query" do
+    include ClientHelper
+    it "should send data to the connection's #post method" do
+      client.connection.should_receive(:execute).
+        with(
+          client, hash_including({
+            :path => "update",
+            :headers => {"Content-Type"=>"text/xml"},
+            :method => :post,
+            :data => "<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><query fq=\"category:&quot;trash&quot;\"/></delete>"
+          })
+        ).
+          and_return(
+            :body => "",
+            :status => 200,
+            :headers => {"Content-Type"=>"text/xml"}
+          )
+      client.delete_by_query :fq => "category:\"trash\""
+    end
+  end
+  
+  context "adapt_response" do
+    include ClientHelper
+    it 'should not try to evaluate ruby when the :qt is not :ruby' do
+      body = '{:time=>"NOW"}'
+      result = client.adapt_response({:params=>{}}, {:status => 200, :body => body, :headers => {}})
+      result.should == body
+    end
+    
+    it 'should evaluate ruby responses when the :wt is :ruby' do
+      body = '{:time=>"NOW"}'
+      result = client.adapt_response({:params=>{:wt=>:ruby}}, {:status => 200, :body => body, :headers => {}})
+      result.should == {:time=>"NOW"}
+    end
+    
+    it "ought raise a RSolr::Error::InvalidRubyResponse when the ruby is indeed frugged, or even fruggified" do
+      lambda {
+        client.adapt_response({:params=>{:wt => :ruby}}, {:status => 200, :body => "<woops/>", :headers => {}})
+      }.should raise_error RSolr::Error::InvalidRubyResponse
+    end
+  
+  end
+  
+  context "build_request" do
+    include ClientHelper
+    it 'should return a request context array' do
+      result = client.build_request('select',
+        :method => :post,
+        :params => {:q=>'test', :fq=>[0,1]},
+        :data => "data",
+        :headers => {}
+      )
+      [/fq=0/, /fq=1/, /q=test/, /wt=ruby/].each do |pattern|
+        result[:query].should match pattern
+      end
+      result[:data].should == "data"
+      result[:headers].should == {}
+    end
+    
+    it "should set the Content-Type header to application/x-www-form-urlencoded if a hash is passed in to the data arg" do
+      result = client.build_request('select',
+        :method => :post,
+        :data => {:q=>'test', :fq=>[0,1]},
+        :headers => {}
+      )
+      result[:query].should == "wt=ruby"
+      [/fq=0/, /fq=1/, /q=test/].each do |pattern|
+        result[:data].should match pattern
+      end
+      result[:data].should_not match /wt=ruby/
+      result[:headers].should == {"Content-Type" => "application/x-www-form-urlencoded"}
+    end
+    
+  end
+  
+end

data/spec/api/connection_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+describe "RSolr::Connection" do
+  
+  context "setup_raw_request" do
+    c = RSolr::Connection.new
+    base_url = "http://localhost:8983/solr"
+    client = RSolr::Client.new c, :url => base_url
+    req = c.send :setup_raw_request, {:headers => {"content-type" => "text/xml"}, :method => :get, :uri => URI.parse(base_url + "/select?q=*:*")}
+    req.path.should == "/solr/select?q=*:*"
+    headers = {}
+    req.each_header{|k,v| headers[k] = v}
+    headers.should == {"content-type"=>"text/xml"}
+  end
+  
+end

data/spec/api/error_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+describe "RSolr::Error" do
+  def generate_error_with_backtrace(request, response)
+    raise RSolr::Error::Http.new request, response
+  rescue RSolr::Error::Http => exception
+    exception
+  end
+
+  context "when the response body is wrapped in a <pre> element" do
+    before do
+      response_lines = (1..15).to_a.map { |i| "line #{i}" }
+
+      @request  = mock :[] => "mocked"
+      @response = {
+        :body   => "<pre>" + response_lines.join("\n") + "</pre>",
+        :status => 400
+      }
+    end
+
+    it "only shows the first eleven lines of the response" do
+      error = generate_error_with_backtrace @request, @response
+      error.to_s.should match(/line 1\n.+line 11\n\n/m)
+    end
+
+    it "shows only one line when the response is one line long" do
+      @response[:body] = "<pre>failed</pre>"
+
+      error = generate_error_with_backtrace @request, @response
+      error.to_s.should match(/Error: failed/)
+    end
+  end
+
+  context "when the response body is not wrapped in a <pre> element" do
+    before do
+      response_lines = (1..15).to_a.map { |i| "line #{i}" }
+
+      @request  = mock :[] => "mocked"
+      @response = {
+        :body   => response_lines.join("\n"),
+        :status => 400
+      }
+    end
+
+    it "only shows the first eleven lines of the response" do
+      error = generate_error_with_backtrace @request, @response
+      error.to_s.should match(/line 1\n.+line 11\n\n/m)
+    end
+
+    it "shows only one line when the response is one line long" do
+      @response[:body] = "failed"
+
+      error = generate_error_with_backtrace @request, @response
+      error.to_s.should match(/Error: failed/)
+    end
+  end
+end

data/spec/api/pagination_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+describe "RSolr::Pagination" do
+  context "build_paginated_request" do
+    it "should create the proper solr params and query string" do
+      c = RSolr::Client.new(nil, {})#.extend(RSolr::Pagination::Client)
+      r = c.build_paginated_request 3, 25, "select", {:params => {:q => "test"}}
+      #r[:page].should == 3
+      #r[:per_page].should == 25
+      r[:params]["start"].should == 50
+      r[:params]["rows"].should == 25
+      r[:uri].query.should =~ /rows=25/
+      r[:uri].query.should =~ /start=50/
+    end
+  end
+  context "paginate" do
+    it "should build a paginated request context and call execute" do
+      c = RSolr::Client.new(nil, {})#.extend(RSolr::Pagination::Client)
+      c.should_receive(:execute).with(hash_including({
+        #:page => 1,
+        #:per_page => 10,
+        :params => {
+          "rows" => 10,
+          "start" => 0,
+          :wt => :ruby
+        }
+      }))
+      c.paginate 1, 10, "select"
+    end
+  end
+end

data/spec/api/rsolr_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+describe "RSolr" do
+  
+  it "has a version that can be read via #version or VERSION" do
+    RSolr.version.should == RSolr::VERSION
+  end
+  
+  it "can escape" do
+    RSolr.should be_a(RSolr::Char)
+    RSolr.escape("this string").should == "this\\ string"
+  end
+  
+  context "connect" do
+    it "should return a RSolr::Client instance" do
+      RSolr.connect.should be_a(RSolr::Client)
+    end
+  end
+  
+end

data/spec/api/uri_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+describe "RSolr::Uri" do
+  
+  context "class-level methods" do
+    
+    let(:uri){ RSolr::Uri }
+    
+    it "should return a URI object with a trailing slash" do
+      u = uri.create 'http://apache.org'
+      u.path[0].should == ?/
+    end
+  
+    it "should return the bytesize of a string" do
+      uri.bytesize("test").should == 4
+    end
+  
+    it "should convert a solr query string from a hash w/o a starting ?" do
+      hash = {:q => "gold", :fq => ["mode:one", "level:2"]}
+      query = uri.params_to_solr hash
+      query[0].should_not == ??
+      [/q=gold/, /fq=mode%3Aone/, /fq=level%3A2/].each do |p|
+        query.should match p
+      end
+      query.split('&').size.should == 3
+    end
+    
+    context "escape_query_value" do
+      
+      it 'should escape &' do
+        uri.params_to_solr(:fq => "&").should == 'fq=%26'
+      end
+
+      it 'should convert spaces to +' do
+        uri.params_to_solr(:fq => "me and you").should == 'fq=me+and+you'
+      end
+
+      it 'should escape comlex queries, part 1' do
+        my_params = {'fq' => '{!raw f=field_name}crazy+\"field+value'}
+        expected = 'fq=%7B%21raw+f%3Dfield_name%7Dcrazy%2B%5C%22field%2Bvalue'
+        uri.params_to_solr(my_params).should == expected
+      end
+
+      it 'should escape complex queries, part 2' do
+        my_params = {'q' => '+popularity:[10 TO *] +section:0'}
+        expected = 'q=%2Bpopularity%3A%5B10+TO+%2A%5D+%2Bsection%3A0'
+        uri.params_to_solr(my_params).should == expected
+      end
+      
+      it 'should escape properly' do
+        uri.escape_query_value('+').should == '%2B'
+        uri.escape_query_value('This is a test').should == 'This+is+a+test'
+        uri.escape_query_value('<>/\\').should == '%3C%3E%2F%5C'
+        uri.escape_query_value('"').should == '%22'
+        uri.escape_query_value(':').should == '%3A'
+      end
+
+      it 'should escape brackets' do
+        uri.escape_query_value('{').should == '%7B'
+        uri.escape_query_value('}').should == '%7D'
+      end
+
+      it 'should escape exclamation marks!' do
+        uri.escape_query_value('!').should == '%21'
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/api/xml_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+describe "RSolr::Xml" do
+  
+  let(:generator){ RSolr::Xml::Generator.new }
+  
+  # call all of the simple methods...
+  # make sure the xml string is valid
+  # ensure the class is actually Solr::XML
+  [:optimize, :rollback, :commit].each do |meth|
+    it "#{meth} should generator xml" do
+      result = generator.send(meth)
+      result.should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?><#{meth}/>"
+    end
+  end
+  
+  context :add do
+    
+    it 'should yield a Message::Document object when #add is called with a block' do
+      documents = [{:id=>1, :name=>'sam', :cat=>['cat 1', 'cat 2']}]
+      add_attrs = {:boost=>200.00}
+      result = generator.add(documents, add_attrs) do |doc|
+        doc.field_by_name(:name).attrs[:boost] = 10
+        doc.fields.size.should == 4
+        doc.fields_by_name(:cat).size.should == 2
+      end
+      result.should match(%r(name="cat">cat 1</field>))
+      result.should match(%r(name="cat">cat 2</field>))
+      result.should match(%r(<add boost="200.0">))
+      result.should match(%r(boost="10"))
+      result.should match(%r(<field name="id">1</field>))
+    end
+    
+    # add a single hash ("doc")
+    it 'should create an add from a hash' do
+      data = {
+        :id=>1,
+        :name=>'matt'
+      }
+      result = generator.add(data)
+      result.should match(/<field name="name">matt<\/field>/)
+      result.should match(/<field name="id">1<\/field>/)
+    end
+
+    # add an array of hashes
+    it 'should create many adds from an array of hashes' do
+      data = [
+        {
+          :id=>1,
+          :name=>'matt'
+        },
+        {
+          :id=>2,
+          :name=>'sam'
+        }
+      ]
+      message = generator.add(data)
+      expected = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><add><doc><field name=\"id\">1</field><field name=\"name\">matt</field></doc><doc><field name=\"id\">2</field><field name=\"name\">sam</field></doc></add>"
+      message.should match(/<field name="name">matt<\/field>/)
+      message.should match(/<field name="name">sam<\/field>/)
+    end
+
+    # multiValue field support test, thanks to Fouad Mardini!
+    it 'should create multiple fields from array values' do
+      data = {
+        :id   => 1,
+        :name => ['matt1', 'matt2']
+      }
+      result = generator.add(data)
+      result.should match(/<field name="name">matt1<\/field>/)
+      result.should match(/<field name="name">matt2<\/field>/)
+    end
+
+    it 'should create an add from a single Message::Document' do
+      document = RSolr::Xml::Document.new
+      document.add_field('id', 1)
+      document.add_field('name', 'matt', :boost => 2.0)
+      result = generator.add(document)
+      result.should match(Regexp.escape('<?xml version="1.0" encoding="UTF-8"?>'))
+      result.should match(/<field name="id">1<\/field>/)
+      result.should match Regexp.escape('boost="2.0"')
+      result.should match Regexp.escape('name="name"')
+      result.should match Regexp.escape('matt</field>')
+    end
+    
+    it 'should create adds from multiple Message::Documents' do
+      documents = (1..2).map do |i|
+        doc = RSolr::Xml::Document.new
+        doc.add_field('id', i)
+        doc.add_field('name', "matt#{i}")
+        doc
+      end
+      result = generator.add(documents)
+      result.should match(/<field name="name">matt1<\/field>/)
+      result.should match(/<field name="name">matt2<\/field>/)
+    end
+    
+  end
+  
+  context :delete_by_id do
+    
+    it 'should create a doc id delete' do
+      generator.delete_by_id(10).should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><id>10</id></delete>"
+    end
+    
+    it 'should create many doc id deletes' do
+      generator.delete_by_id([1, 2, 3]).should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><id>1</id><id>2</id><id>3</id></delete>"
+    end
+    
+  end
+  
+  context :delete_by_query do
+    it 'should create a query delete' do
+      generator.delete_by_query('status:"LOST"').should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><query>status:\"LOST\"</query></delete>"
+    end
+    
+    it 'should create many query deletes' do
+      generator.delete_by_query(['status:"LOST"', 'quantity:0']).should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><query>status:\"LOST\"</query><query>quantity:0</query></delete>"
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.expand_path('../../lib/rsolr', __FILE__)

data/tasks/rdoc.rake

@@ -0,0 +1,11 @@
+# Rdoc
+require "rdoc/task"
+
+desc 'Generate documentation for the rsolr gem.'
+RDoc::Task.new(:doc) do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = 'RSolr'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/tasks/spec.rake

@@ -0,0 +1,39 @@
+require "rubygems"
+require 'rspec'
+require 'rspec/core/rake_task'
+
+namespace :spec do
+  
+  namespace :ruby do
+    desc 'run api specs through the Ruby implementations'
+    task :api do
+      puts "Ruby 1.8.7"
+      puts `rake spec:api`
+      puts "Ruby 1.9"
+      puts `rake1.9 spec:api`
+      puts "JRuby"
+      puts `jruby -S rake spec:api`
+    end
+  end
+  
+  desc 'run api specs (mock out Solr dependency)'
+  RSpec::Core::RakeTask.new(:api) do |t|
+    
+    t.pattern = [File.join('spec', 'spec_helper.rb')]
+    t.pattern += FileList[File.join('spec', 'api', '**', '*_spec.rb')]
+    
+    t.verbose = true
+    t.rspec_opts = ['--color']
+  end
+  
+  desc 'run integration specs'
+  RSpec::Core::RakeTask.new(:integration) do |t|
+    
+    t.pattern = [File.join('spec', 'spec_helper.rb')]
+    t.pattern += FileList[File.join('spec', 'integration', '**', '*_spec.rb')]
+    
+    t.verbose = true
+    t.rspec_opts = ['--color']
+  end
+  
+end