telvue-rsolr 2.2.2

data/spec/api/document_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+RSpec.describe RSolr::Document do
+  describe RSolr::Field do
+    describe ".instance" do
+      subject { RSolr::Field }
+
+      it "uses the class name of the field value" do
+        expect(subject.instance({}, Time.new)).to be_a_kind_of(RSolr::TimeField)
+      end
+
+      it "uses the provided type option when it is a class" do
+        expect(subject.instance({:type => RSolr::TimeField}, nil)).to be_a_kind_of(RSolr::TimeField)
+      end
+
+      it "uses the provided type option when it is a string" do
+        expect(subject.instance({:type => 'Time'}, nil)).to be_a_kind_of(RSolr::TimeField)
+      end
+
+      it "falls back to the base Field class" do
+        expect(subject.instance({:type => 'UndefinedType'}, nil)).to be_a_kind_of(RSolr::Field)
+      end
+
+      it "defaults to the base Field class" do
+        expect(subject.instance({}, nil)).to be_a_kind_of(RSolr::Field)
+      end
+    end
+  end
+
+  describe RSolr::TimeField do
+    it "convert value to string" do
+      time_value = Time.utc(2013, 9, 11, 18, 10, 0)
+      expect(RSolr::Field.instance({}, time_value).value).to eq '2013-09-11T18:10:00Z'
+    end
+
+    it "convert time to UTC" do
+      time_value = Time.new(2013, 9, 11, 18, 10, 0, '+02:00')
+      expect(RSolr::Field.instance({}, time_value).value).to eq '2013-09-11T16:10:00Z'
+    end
+  end
+
+  describe RSolr::DateField do
+    it "convert value to string" do
+      date_value = Date.new(2013, 9, 11)
+      expect(RSolr::Field.instance({}, date_value).value).to eq '2013-09-11T00:00:00Z'
+    end
+  end
+end

data/spec/api/error_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+RSpec.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
+  let (:response_lines) { (1..15).to_a.map { |i| "line #{i}" } }
+  let(:request)  { double :[] => "mocked" }
+  let(:response_body) { response_lines.join("\n") }
+  let(:response) {{
+    :body   => response_body,
+    :status => 400
+  }}
+  subject { generate_error_with_backtrace(request, response).to_s }
+
+  context "when the response body is wrapped in a <pre> element" do
+    let(:response_body) { "<pre>" + response_lines.join("\n") + "</pre>" }
+
+    it "only shows the first eleven lines of the response" do
+      expect(subject).to match(/line 1\n.+line 11\n\n/m)
+    end
+
+    context "when the response is one line long" do
+      let(:response_body) { "<pre>failed</pre>" }
+      it { should match(/Error: failed/) }
+    end
+  end
+
+  context "when the response body is not wrapped in a <pre> element" do
+
+    it "only shows the first eleven lines of the response" do
+      expect(subject).to match(/line 1\n.+line 11\n\n/m)
+    end
+
+    context "when the response is one line long" do
+      let(:response_body) { 'failed' }
+      it { should match(/Error: failed/) }
+    end
+    context "when the response body contains a msg key" do
+      let(:msg) { "'org.apache.solr.search.SyntaxError: Cannot parse \\':false\\': Encountered \" \":\" \": \"\" at line 1, column 0.'" }
+      let(:response_body) { (response_lines << "'error'=>{'msg'=> #{msg}").join("\n") }
+      it { should include msg }
+    end
+  end
+end

data/spec/api/json_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+
+RSpec.describe RSolr::JSON do
+
+  let(:generator){ RSolr::JSON::Generator.new }
+
+  context :add do
+    # add a single hash ("doc")
+    it 'should create an add from a hash' do
+      data = {
+        :id=>"1",
+        :name=>'matt'
+      }
+      message = JSON.parse(generator.add(data), symbolize_names: true)
+      expect(message.length).to eq 1
+      expect(message.first).to eq data
+    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 = JSON.parse(generator.add(data), symbolize_names: true)
+      expect(message).to eq data
+    end
+
+    it 'should yield a Document object when #add is called with a block' do
+      documents = [{:id=>1, :name=>'sam', :cat=>['cat 1', 'cat 2']}]
+      result = generator.add(documents) do |doc|
+        doc.field_by_name(:name).attrs[:boost] = 10
+      end
+
+      message = JSON.parse(result, symbolize_names: true)
+
+      expect(message.length).to eq 1
+      expect(message.first).to include name: { boost: 10, value: 'sam' }
+    end
+
+    context 'with add_attr' do
+      it 'should create an add command with the attributes from a hash' do
+        data = {
+          :id=>"1",
+          :name=>'matt'
+        }
+        message = JSON.parse(generator.add(data, boost: 1), symbolize_names: true)
+        expect(message).to include :add
+        expect(message[:add][:doc]).to eq data
+        expect(message[:add][:boost]).to eq 1
+      end
+
+      it 'should create multiple add command with the attributes from a hash' do
+        data = [
+          {
+            :id=>"1",
+            :name=>'matt'
+          },
+          {
+            :id=>"2",
+            :name=>'sam'
+          },
+        ]
+
+        # custom JSON object class to handle Solr's non-standard JSON command format
+        tmp = Class.new do
+          def initialize
+            @source ||= {}
+          end
+
+          def []=(k, v)
+            if k == :add
+              @source[k] ||= []
+              @source[k] << v.to_h
+            elsif v.class == self.class
+              @source[k] = v.to_h
+            else
+              @source[k] = v
+            end
+          end
+
+          def to_h
+            @source
+          end
+        end
+
+        request = generator.add(data, boost: 1)
+        message = JSON.parse(request, object_class: tmp, symbolize_names: true).to_h
+        expect(message[:add].length).to eq 2
+        expect(message[:add].map { |x| x[:doc] }).to eq data
+      end
+    end
+
+    it 'allows for atomic updates' do
+      data = {
+        foo: { set: 'Bar' }
+      }
+
+      message = JSON.parse(generator.add(data), symbolize_names: true)
+      expect(message.length).to eq 1
+      expect(message.first).to eq data
+    end
+
+    it 'supports nested child documents' do
+      data = {
+        _childDocuments_: [
+          {
+            id: 1
+          },
+          {
+            id: 2
+          }
+        ]
+      }
+
+      message = JSON.parse(generator.add(data), symbolize_names: true)
+      expect(message.length).to eq 1
+      expect(message.first).to eq data
+    end
+
+    it 'supports nested child documents with only a single document' do
+      data = {
+        _childDocuments_: [
+          {
+            id: 1
+          }
+        ]
+      }
+
+      message = JSON.parse(generator.add(data), symbolize_names: true)
+      expect(message.length).to eq 1
+      expect(message.first).to eq data
+    end
+  end
+
+  it 'should create multiple fields from array values' do
+    data = {
+      :id   => "1",
+      :name => ['matt1', 'matt2']
+    }
+    message = JSON.parse(generator.add(data), symbolize_names: true)
+    expect(message.length).to eq 1
+    expect(message.first).to eq data
+  end
+
+  it 'should create multiple fields from array values with options' do
+    test_values = [nil, 'matt1', 'matt2']
+    message = JSON.parse(
+      generator.add(id: '1') { |doc| doc.add_field(:name, test_values, boost: 3) },
+      symbolize_names: true
+    )
+    expect(message).to eq [{ id: '1', name: { boost: 3, value: test_values } }]
+  end
+
+  describe '#commit' do
+    it 'generates a commit command' do
+      expect(JSON.parse(generator.commit, symbolize_names: true)).to eq(commit: {})
+    end
+  end
+
+  describe '#optimize' do
+    it 'generates a optimize command' do
+      expect(JSON.parse(generator.optimize, symbolize_names: true)).to eq(optimize: {})
+    end
+  end
+
+  describe '#rollback' do
+    it 'generates a rollback command' do
+      expect(JSON.parse(generator.rollback, symbolize_names: true)).to eq(rollback: {})
+    end
+  end
+
+  describe '#delete_by_id' do
+    it 'generates a delete_by_id command for single documents' do
+      expect(JSON.parse(generator.delete_by_id('x'), symbolize_names: true)).to eq(delete: 'x')
+    end
+
+    it 'generates a delete_by_id command for an array of documents' do
+      expect(JSON.parse(generator.delete_by_id(%w(a b c)), symbolize_names: true)).to eq(delete: %w(a b c))
+    end
+  end
+
+  describe '#delete_by_query' do
+    it 'generates a delete_by_id command for single documents' do
+      expect(JSON.parse(generator.delete_by_query('id:x'), symbolize_names: true)).to eq(delete: { query: 'id:x'})
+    end
+
+    it 'generates a delete_by_id command for an array of documents' do
+      expect(JSON.parse(generator.delete_by_id(%w(a b c)), symbolize_names: true)).to eq(delete: %w(a b c))
+    end
+  end
+end

data/spec/api/pagination_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+RSpec.describe RSolr::Client 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
+      expect(r[:params]["start"]).to eq(50)
+      expect(r[:params]["rows"]).to eq(25)
+      expect(r[:uri].query).to match(/rows=25/)
+      expect(r[:uri].query).to match(/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)
+      expect(c).to receive(:execute).with(hash_including({
+        #:page => 1,
+        #:per_page => 10,
+        :params => {
+          "rows" => 10,
+          "start" => 0,
+          :wt => :json
+        }
+      }))
+      c.paginate 1, 10, "select"
+    end
+  end
+end

data/spec/api/rsolr_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+RSpec.describe RSolr do
+  
+  it "has a version that can be read via #version or VERSION" do
+    expect(RSolr.version).to eq(RSolr::VERSION)
+  end
+
+  context "connect" do
+    it "should return a RSolr::Client instance" do
+      expect(RSolr.connect).to be_a(RSolr::Client)
+    end
+  end
+  
+  context '.solr_escape' do
+    it "adds backslash to Solr query syntax chars" do
+      # per http://lucene.apache.org/core/4_0_0/queryparser/org/apache/lucene/queryparser/classic/package-summary.html#Escaping_Special_Characters
+      special_chars = [ "+", "-", "&", "|", "!", "(", ")", "{", "}", "[", "]", "^", '"', "~", "*", "?", ":", "\\", "/" ]
+      escaped_str = RSolr.solr_escape("aa#{special_chars.join('aa')}aa")
+      special_chars.each { |c|
+        # note that the ruby code sending the query to Solr will un-escape the backslashes
+        # so the result sent to Solr is ultimately a single backslash in front of the particular character 
+        expect(escaped_str).to match "\\#{c}"
+      }
+    end
+    it "leaves other chars alone" do
+      str = "nothing to see here; let's move along people."
+      expect(RSolr.solr_escape(str)).to eq str
+    end
+  end
+end

data/spec/api/uri_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+RSpec.describe RSolr::Uri do
+  
+  let(:uri) { RSolr::Uri }
+
+  context '.params_to_solr' do
+    it "converts Hash to Solr query string w/o a starting ?" do
+      hash = {:q => "gold", :fq => ["mode:one", "level:2"]}
+      query = uri.params_to_solr hash
+      expect(query[0]).not_to eq(??)
+      [/q=gold/, /fq=mode%3Aone/, /fq=level%3A2/].each do |p|
+        expect(query).to match p
+      end
+      expect(query.split('&').size).to eq(3)
+    end
+    it 'should URL escape &' do
+      expect(uri.params_to_solr(:fq => "&")).to eq('fq=%26')
+    end
+
+    it 'should convert spaces to +' do
+      expect(uri.params_to_solr(:fq => "me and you")).to eq('fq=me+and+you')
+    end
+
+    it 'should URL escape complex 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'
+      expect(uri.params_to_solr(my_params)).to eq(expected)
+    end
+
+    it 'should URL escape complex queries, part 2' do
+      my_params = {'q' => '+popularity:[10 TO *] +section:0'}
+      expected = 'q=%2Bpopularity%3A%5B10+TO+*%5D+%2Bsection%3A0'
+      expect(uri.params_to_solr(my_params)).to eq(expected)
+    end
+  end
+end

data/spec/api/xml_spec.rb

@@ -0,0 +1,255 @@
+require 'spec_helper'
+require 'builder'
+require 'nokogiri'
+
+RSpec.describe RSolr::Xml do
+  let(:generator){ RSolr::Xml::Generator.new }
+
+  builder_engines = { 
+    :builder   => { :val => false, :class => Builder::XmlMarkup, :engine => Builder::XmlMarkup.new(:indent => 0, :margin => 0, :encoding => 'UTF-8') },
+    :nokogiri  => { :val => true,  :class => Nokogiri::XML::Builder, :engine => Nokogiri::XML::Builder.new }
+  }
+
+  [:builder,:nokogiri].each do |engine_name|
+    describe engine_name do
+      before :all do
+        @engine = builder_engines[engine_name]
+        @old_ng_setting = RSolr::Xml::Generator.use_nokogiri
+        RSolr::Xml::Generator.use_nokogiri = @engine[:val]
+      end
+
+      after :all do
+        RSolr::Xml::Generator.use_nokogiri = @old_ng_setting
+      end
+  
+      before :each do
+        builder_engines.each_pair do |name,spec|
+          expect(spec[:class]).not_to receive(:new) unless name == engine_name
+        end
+      end
+
+      context :xml_engine do
+        it "should use #{engine_name}" do
+          expect(@engine[:class]).to receive(:new).and_return(@engine[:engine])
+          generator.send(:commit)
+        end
+      end
+  
+      # 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)
+          expect(result).to eq("<?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
+          end
+          expect(result).to match(%r(name="cat">cat 1</field>))
+          expect(result).to match(%r(name="cat">cat 2</field>))
+          expect(result).to match(%r(<add boost="200.0">))
+          expect(result).to match(%r(boost="10"))
+          expect(result).to match(%r(<field name="id">1</field>))
+        end
+
+        it 'should work for values that yield enumerators' do
+          documents = [{id: 1, cat: ['cat 1', 'cat 2'].to_enum}]
+          result = generator.add(documents)
+
+          expect(result).to match(%r(name="cat">cat 1</field>))
+          expect(result).to match(%r(name="cat">cat 2</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)
+          expect(result).to match(/<field name="name">matt<\/field>/)
+          expect(result).to match(/<field name="id">1<\/field>/)
+        end
+
+        # add a single hash ("doc")
+        it 'should create an add from a hash formatted for atomic updates' do
+          data = {
+            :id=>1,
+            :name=> { set: 'matt' }
+          }
+          result = generator.add(data)
+          expect(result).to match(/<field name="name" update="set">matt<\/field>/)
+          expect(result).to match(/<field name="id">1<\/field>/)
+        end
+        it 'should remove a field from a hash formatted for atomic updates' do
+          data = {
+            :id => 1,
+            :name => nil
+          }
+          result = generator.add(data)
+          expect(result).to match(%r{<field name="name" null="true"})
+          expect(result).to 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)
+          expect(message).to match %r{<field name="name">matt</field>}
+          expect(message).to match %r{<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)
+          expect(result).to match(/<field name="name">matt1<\/field>/)
+          expect(result).to match(/<field name="name">matt2<\/field>/)
+        end
+
+        it 'should allow for objects which can be casted to an array' do
+          name = double("name", to_ary: ['matt1', 'matt2'])
+          data = {
+            :id => 1,
+            :name => name
+          }
+          result = generator.add(data)
+          expect(result).to match(/<field name="name">matt1<\/field>/)
+          expect(result).to match(/<field name="name">matt2<\/field>/)
+        end
+
+        it 'should create an add from a single Message::Document' do
+          document = RSolr::Document.new
+          document.add_field('id', 1)
+          document.add_field('name', 'matt', :boost => 2.0)
+          result = generator.add(document)
+          expect(result).to match(Regexp.escape('<?xml version="1.0" encoding="UTF-8"?>'))
+          expect(result).to match(/<field name="id">1<\/field>/)
+          expect(result).to match Regexp.escape('boost="2.0"')
+          expect(result).to match Regexp.escape('name="name"')
+          expect(result).to match Regexp.escape('matt</field>')
+        end
+    
+        it 'should create adds from multiple Message::Documents' do
+          documents = (1..2).map do |i|
+            doc = RSolr::Document.new
+            doc.add_field('id', i)
+            doc.add_field('name', "matt#{i}")
+            doc
+          end
+          result = generator.add(documents)
+          expect(result).to match(/<field name="name">matt1<\/field>/)
+          expect(result).to match(/<field name="name">matt2<\/field>/)
+        end
+
+        it 'supports nested child documents' do
+          data = {
+            :_childDocuments_ => [
+              {
+                :id => 1
+              },
+              {
+                :id => 2
+              }
+            ]
+          }
+
+          result = generator.add(data)
+          expect(result).to match(%r{<add><doc><doc>})
+          expect(result).to match(%r{<doc><field name="id">1</field></doc>})
+          expect(result).to match(%r{<doc><field name="id">2</field></doc>})
+        end
+      end
+  
+      context :delete_by_id do
+    
+        it 'should create a doc id delete' do
+          expect(generator.delete_by_id(10)).to eq("<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><id>10</id></delete>")
+        end
+    
+        it 'should create many doc id deletes' do
+          expect(generator.delete_by_id([1, 2, 3])).to eq("<?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
+          expect(generator.delete_by_query('status:"LOST"')).to eq("<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><query>status:\"LOST\"</query></delete>")
+        end
+    
+        it 'should create many query deletes' do
+          expect(generator.delete_by_query(['status:"LOST"', 'quantity:0'])).to eq("<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><query>status:\"LOST\"</query><query>quantity:0</query></delete>")
+        end
+      end
+
+    end
+  end
+
+  context :formatting do
+    it 'should format date objects into ISO 8601' do
+      data = {
+        dt: Date.new(1992, 03, 15)
+      }
+      result = generator.add(data)
+      expect(result).to match(/<field name="dt">1992-03-15T00:00:00Z<\/field>/)
+    end
+
+    it 'should format time objects into ISO 8601' do
+      data = {
+        dt: Time.new(1992, 03, 15, 16, 23, 55, 3600)
+      }
+      result = generator.add(data)
+      expect(result).to match(/<field name="dt">1992-03-15T15:23:55Z<\/field>/)
+    end
+
+    it 'should format datetime objects into ISO 8601' do
+      data = {
+        dt: DateTime.new(1992, 03, 15, 16, 23, 55, '+1')
+      }
+      result = generator.add(data)
+      expect(result).to match(/<field name="dt">1992-03-15T15:23:55Z<\/field>/)
+    end
+
+    it 'passes through other values' do
+      data = {
+        whatever: 'some string'
+      }
+
+      result = generator.add(data)
+      expect(result).to match(/<field name="whatever">some string<\/field>/)
+    end
+
+    # rails monkey-patches String to add a #to_time casting..
+    context 'with rails monkey patching' do
+      it 'passes through string values' do
+        data = {
+          whatever: double(to_s: 'some string', to_time: nil)
+        }
+
+        result = generator.add(data)
+        expect(result).to match(/<field name="whatever">some string<\/field>/)
+      end
+    end
+  end  
+end