harvestdor-indexer 2.1.1 → 2.2.0

data/spec/unit/harvestdor-indexer-resource_spec.rb

@@ -1,50 +1,78 @@
 require 'spec_helper'
 
 describe Harvestdor::Indexer::Resource do
-  
+
   before(:all) do
     VCR.use_cassette('before_all_call') do
-      @config_yml_path = File.join(File.dirname(__FILE__), "..", "config", "ap.yml")
+      @config_yml_path = File.join(File.dirname(__FILE__), '..', 'config', 'ap.yml')
       require 'yaml'
       @config = YAML.load_file(@config_yml_path)
       @fake_druid = 'oo000oo0000'
-      
+
       @indexer = Harvestdor::Indexer.new(@config)
       @hdor_client = @indexer.send(:harvestdor_client)
-      @whitelist_path = File.join(File.dirname(__FILE__), "../config/ap_whitelist.txt")
+      @whitelist_path = File.join(File.dirname(__FILE__), '../config/ap_whitelist.txt')
     end
   end
 
   let :resource do
-    Harvestdor::Indexer::Resource.new(@indexer, @fake_druid)
+    described_class.new(@indexer, @fake_druid)
   end
-  
-  context "smods_rec method" do
+
+  subject { resource }
+
+  describe '#items' do
+    context 'for a regular item' do
+      before do
+        allow(subject).to receive(:collection?).and_return(false)
+      end
+
+      it 'is empty if it is not a collection' do
+        expect(subject.items).to be_empty
+      end
+    end
+
+    context 'for a collection' do
+      before do
+        allow(subject).to receive(:collection?).and_return(true)
+        allow(subject).to receive(:items_druids).and_return %w(oo000oo0001 oo000oo0002)
+      end
+
+      it 'enumerates the items in the collection' do
+        expect(subject.items.count).to eq 2
+
+        child = subject.items.first
+        expect(child.druid).to eq 'oo000oo0001'
+      end
+    end
+  end
+
+  context 'smods_rec method' do
     before(:all) do
       @ns_decl = "xmlns='#{Mods::MODS_NS}'"
       @mods_xml = "<mods #{@ns_decl}><note>hi</note></mods>"
-      @ng_mods_xml = Nokogiri::XML(@mods_xml)      
+      @ng_mods_xml = Nokogiri::XML(@mods_xml)
     end
-    it "should call mods method on harvestdor_client" do
+    it 'calls mods method on harvestdor_client' do
       expect(@hdor_client).to receive(:mods).with(@fake_druid).and_return(@ng_mods_xml)
       resource.smods_rec
     end
-    it "should return Stanford::Mods::Record object" do
+    it 'returns Stanford::Mods::Record object' do
       expect(@hdor_client).to receive(:mods).with(@fake_druid).and_return(@ng_mods_xml)
       expect(resource.smods_rec).to be_an_instance_of(Stanford::Mods::Record)
     end
-    it "should raise exception if MODS xml for the druid is empty" do
+    it 'raises exception if MODS xml for the druid is empty' do
       allow(@hdor_client).to receive(:mods).with(@fake_druid).and_return(Nokogiri::XML("<mods #{@ns_decl}/>"))
       expect { resource.smods_rec }.to raise_error(RuntimeError, Regexp.new("^Empty MODS metadata for #{@fake_druid}: <"))
     end
-    it "should raise exception if there is no MODS xml for the druid" do
+    it 'raises exception if there is no MODS xml for the druid' do
       VCR.use_cassette('exception_no_MODS_call') do
         expect { resource.smods_rec }.to raise_error(Harvestdor::Errors::MissingMods)
       end
     end
   end
-  
-  context "public_xml related methods" do
+
+  context 'public_xml related methods' do
     before(:all) do
       @id_md_xml = "<identityMetadata><objectId>druid:#{@fake_druid}</objectId></identityMetadata>"
       @cntnt_md_xml = "<contentMetadata type='image' objectId='#{@fake_druid}'>foo</contentMetadata>"
@@ -53,29 +81,29 @@ describe Harvestdor::Indexer::Resource do
       @pub_xml = "<publicObject id='druid:#{@fake_druid}'>#{@id_md_xml}#{@cntnt_md_xml}#{@rights_md_xml}#{@rdf_xml}</publicObject>"
       @ng_pub_xml = Nokogiri::XML(@pub_xml)
     end
-    context "#public_xml" do
-      it "should call public_xml method on harvestdor_client" do
+    context '#public_xml' do
+      it 'calls public_xml method on harvestdor_client' do
         expect(@hdor_client).to receive(:public_xml).with(@fake_druid).and_return(@ng_pub_xml)
         resource.public_xml
       end
-      it "retrieves entire public xml as a Nokogiri::XML::Document" do
+      it 'retrieves entire public xml as a Nokogiri::XML::Document' do
         expect(@hdor_client).to receive(:public_xml).with(@fake_druid).and_return(@ng_pub_xml)
         px = resource.public_xml
         expect(px).to be_kind_of(Nokogiri::XML::Document)
         expect(px.root.name).to eq('publicObject')
         expect(px.root.attributes['id'].text).to eq("druid:#{@fake_druid}")
       end
-      it "raises exception if public xml for the druid is empty" do
-        expect(@hdor_client).to receive(:public_xml).with(@fake_druid).and_return(Nokogiri::XML("<publicObject/>"))
+      it 'raises exception if public xml for the druid is empty' do
+        expect(@hdor_client).to receive(:public_xml).with(@fake_druid).and_return(Nokogiri::XML('<publicObject/>'))
         expect { resource.public_xml }.to raise_error(RuntimeError, Regexp.new("^Empty public xml for #{@fake_druid}: <"))
       end
-      it "raises error if there is no public_xml page for the druid" do
+      it 'raises error if there is no public_xml page for the druid' do
         expect(@hdor_client).to receive(:public_xml).with(@fake_druid).and_return(nil)
         expect { resource.public_xml }.to raise_error(RuntimeError, "No public xml for #{@fake_druid}")
       end
     end
-    context "#content_metadata" do
-      it "returns a Nokogiri::XML::Document derived from the public xml if a druid is passed" do
+    context '#content_metadata' do
+      it 'returns a Nokogiri::XML::Document derived from the public xml if a druid is passed' do
         allow(Harvestdor).to receive(:public_xml).with(@fake_druid, @indexer.config.harvestdor.purl).and_return(@ng_pub_xml)
         cm = resource.content_metadata
         expect(cm).to be_kind_of(Nokogiri::XML::Document)
@@ -84,13 +112,13 @@ describe Harvestdor::Indexer::Resource do
         expect(cm.root.attributes['objectId'].text).to eq(@fake_druid)
         expect(cm.root.text.strip).to eq('foo')
       end
-      it "raises RuntimeError if nil is returned by Harvestdor::Client.contentMetadata for the druid" do
+      it 'raises RuntimeError if nil is returned by Harvestdor::Client.contentMetadata for the druid' do
         expect(@hdor_client).to receive(:content_metadata).with(@fake_druid).and_return(nil)
         expect { resource.content_metadata }.to raise_error(RuntimeError, "No contentMetadata for \"#{@fake_druid}\"")
       end
     end
-    context "#identity_metadata" do
-      it "returns a Nokogiri::XML::Document derived from the public xml if a druid is passed" do
+    context '#identity_metadata' do
+      it 'returns a Nokogiri::XML::Document derived from the public xml if a druid is passed' do
         allow(Harvestdor).to receive(:public_xml).with(@fake_druid, @indexer.config.harvestdor.purl).and_return(@ng_pub_xml)
         im = resource.identity_metadata
         expect(im).to be_kind_of(Nokogiri::XML::Document)
@@ -98,61 +126,61 @@ describe Harvestdor::Indexer::Resource do
         expect(im.root.name).to eq('identityMetadata')
         expect(im.root.text.strip).to eq("druid:#{@fake_druid}")
       end
-      it "raises RuntimeError if nil is returned by Harvestdor::Client.identityMetadata for the druid" do
+      it 'raises RuntimeError if nil is returned by Harvestdor::Client.identityMetadata for the druid' do
         expect(@hdor_client).to receive(:identity_metadata).with(@fake_druid).and_return(nil)
         expect { resource.identity_metadata }.to raise_error(RuntimeError, "No identityMetadata for \"#{@fake_druid}\"")
       end
     end
-    context "#rights_metadata" do
-      it "returns a Nokogiri::XML::Document derived from the public xml if a druid is passed" do
+    context '#rights_metadata' do
+      it 'returns a Nokogiri::XML::Document derived from the public xml if a druid is passed' do
         allow(Harvestdor).to receive(:public_xml).with(@fake_druid, @indexer.config.harvestdor.purl).and_return(@ng_pub_xml)
         im = resource.rights_metadata
         expect(im).to be_kind_of(Nokogiri::XML::Document)
         expect(im.root).not_to eq(nil)
         expect(im.root.name).to eq('rightsMetadata')
-        expect(im.root.text.strip).to eq("bar")
+        expect(im.root.text.strip).to eq('bar')
       end
-      it "raises RuntimeError if nil is returned by Harvestdor::Client.rightsMetadata for the druid" do
+      it 'raises RuntimeError if nil is returned by Harvestdor::Client.rightsMetadata for the druid' do
         expect(@hdor_client).to receive(:rights_metadata).with(@fake_druid).and_return(nil)
         expect { resource.rights_metadata }.to raise_error(RuntimeError, "No rightsMetadata for \"#{@fake_druid}\"")
       end
     end
-    context "#rdf" do
-      it "returns a Nokogiri::XML::Document derived from the public xml if a druid is passed" do
+    context '#rdf' do
+      it 'returns a Nokogiri::XML::Document derived from the public xml if a druid is passed' do
         allow(Harvestdor).to receive(:public_xml).with(@fake_druid, @indexer.config.harvestdor.purl).and_return(@ng_pub_xml)
         im = resource.rdf
         expect(im).to be_kind_of(Nokogiri::XML::Document)
         expect(im.root).not_to eq(nil)
         expect(im.root.name).to eq('RDF')
-        expect(im.root.text.strip).to eq("relationship!")
+        expect(im.root.text.strip).to eq('relationship!')
       end
-      it "raises RuntimeError if nil is returned by Harvestdor::Client.rdf for the druid" do
+      it 'raises RuntimeError if nil is returned by Harvestdor::Client.rdf for the druid' do
         expect(@hdor_client).to receive(:rdf).with(@fake_druid).and_return(nil)
         expect { resource.rdf }.to raise_error(RuntimeError, "No RDF for \"#{@fake_druid}\"")
       end
     end
-    
-    describe "#public_xml_or_druid" do
-      it "should return the public_xml, if the public_xml has been loaded" do
+
+    describe '#public_xml_or_druid' do
+      it 'returns the public_xml, if the public_xml has been loaded' do
         allow(resource).to receive(:public_xml?).and_return(true)
         allow(resource).to receive(:public_xml).and_return(double)
         expect(resource.public_xml_or_druid).to eq resource.public_xml
       end
-      it "should return the druid, if the public_xml has not been loaded" do
+      it 'returns the druid, if the public_xml has not been loaded' do
         allow(resource).to receive(:public_xml?).and_return(false)
         expect(resource.public_xml_or_druid).to eq @fake_druid
       end
     end
 
-    describe "#identity_md_obj_label" do
-      it "should extract the objectLabel from the identity metadata" do
-        allow(resource).to receive(:identity_metadata).and_return(Nokogiri::XML("<identityMetadata><objectLabel>label</objectLabel></identityMetadata>"))
-        expect(resource.identity_md_obj_label).to eq "label"
+    describe '#identity_md_obj_label' do
+      it 'extracts the objectLabel from the identity metadata' do
+        allow(resource).to receive(:identity_metadata).and_return(Nokogiri::XML('<identityMetadata><objectLabel>label</objectLabel></identityMetadata>'))
+        expect(resource.identity_md_obj_label).to eq 'label'
       end
     end
 
-    describe "#collections" do
-      it "should extract the collection this resource is a member of and return Resource objects for those collections" do
+    describe '#collections' do
+      it 'extracts the collection this resource is a member of and return Resource objects for those collections' do
         allow(resource).to receive(:public_xml).and_return(Nokogiri::XML <<-EOF
 <publicObject>
   <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:fedora="info:fedora/fedora-system:def/relations-external#">
@@ -162,13 +190,13 @@ describe Harvestdor::Indexer::Resource do
   </rdf:RDF>
 </publicObject>
 EOF
-        )
+                                                          )
 
         expect(resource.collections.length).to eq 1
-        expect(resource.collections.first.druid).to eq "some:druid"
+        expect(resource.collections.first.druid).to eq 'some:druid'
         expect(resource.collections.first.indexer).to eq resource.indexer
       end
     end
   end
-  
+
 end

data/spec/unit/harvestdor-indexer-solr_spec.rb

@@ -2,28 +2,28 @@ require 'spec_helper'
 
 describe Harvestdor::Indexer::Solr do
   let :indexer do
-    double(logger: Logger.new("/dev/null"))
+    double(logger: Logger.new('/dev/null'))
   end
 
   let :solr do
-    Harvestdor::Indexer::Solr.new indexer
+    described_class.new indexer
   end
 
   # The method that sends the solr document to solr
-  describe "#add" do
+  describe '#add' do
     let(:doc_hash) do
       {
-        :id => "whatever",
-        :modsxml => 'whatever',
-        :title_display => 'title',
-        :pub_year_tisim => 'some year',
-        :author_person_display => 'author',
-        :format => 'Image',
-        :language => 'English'
+        id: 'whatever',
+        modsxml: 'whatever',
+        title_display: 'title',
+        pub_year_tisim: 'some year',
+        author_person_display: 'author',
+        format: 'Image',
+        language: 'English'
       }
     end
 
-    it "sends an add request to the solr_client" do
+    it 'sends an add request to the solr_client' do
       expect(solr.client).to receive(:add).with(doc_hash)
       solr.add(doc_hash)
     end

data/spec/unit/harvestdor-indexer_spec.rb

@@ -4,48 +4,62 @@ describe Harvestdor::Indexer do
 
   before(:all) do
     VCR.use_cassette('before_all_call') do
-      @config_yml_path = File.join(File.dirname(__FILE__), "..", "config", "ap.yml")
+      @config_yml_path = File.join(File.dirname(__FILE__), '..', 'config', 'ap.yml')
       require 'yaml'
       @config = YAML.load_file(@config_yml_path)
 
-      @indexer = Harvestdor::Indexer.new(@config) do |config|
-        config.whitelist = ["druid:yg867hg1375"]
+      @indexer = described_class.new(@config) do |config|
+        config.whitelist = ['druid:yg867hg1375']
       end
       @hdor_client = @indexer.send(:harvestdor_client)
       @fake_druid = 'druid:oo000oo0000'
-      @whitelist_path = File.join(File.dirname(__FILE__), "../config/ap_whitelist.txt")
+      @whitelist_path = File.join(File.dirname(__FILE__), '../config/ap_whitelist.txt')
     end
   end
 
-  describe "access methods" do
-    it "initializes success count" do
+  describe 'access methods' do
+    it 'initializes success count' do
       expect(@indexer.metrics.success_count).to eq(0)
     end
-    it "initializes error count" do
+    it 'initializes error count' do
       expect(@indexer.metrics.error_count).to eq(0)
     end
   end
 
-  describe "logging" do
-    it "writes the log file to the directory indicated by log_dir" do
-      @indexer.logger.info("indexer_spec logging test message")
-      expect(File.exists?(File.join(@config['harvestdor']['log_dir'], @config['harvestdor']['log_name']))).to eq(true)
+  describe 'logging' do
+    it 'writes the log file to the directory indicated by log_dir' do
+      @indexer.logger.info('indexer_spec logging test message')
+      expect(File.exist?(File.join(@config['harvestdor']['log_dir'], @config['harvestdor']['log_name']))).to eq(true)
     end
   end
 
-  it "initializes the harvestdor_client from the config" do
+  it 'initializes the harvestdor_client from the config' do
     expect(@hdor_client).to be_an_instance_of(Harvestdor::Client)
     expect(@hdor_client.config.default_set).to eq(@config['harvestdor']['default_set'])
   end
 
-  context "harvest_and_index" do
+  describe '#resources' do
+    it 'does not persist resources across calls' do
+      VCR.use_cassette('single_rsolr_connection_call') do
+        hdor_client = @indexer.send(:harvestdor_client)
+        allow(@indexer.dor_fetcher_client).to receive(:druid_array).and_return(['druid:yg867hg1375', 'druid:jf275fd6276', 'druid:nz353cp1092', 'druid:tc552kq0798', 'druid:th998nk0722', 'druid:ww689vs6534'])
+
+        a = @indexer.resources.first
+        b = @indexer.resources.first
+
+        expect(a).to_not eq b
+      end
+    end
+  end
+
+  context 'harvest_and_index' do
     before(:all) do
       @doc_hash = {
-        :id => @fake_druid
+        id: @fake_druid
       }
     end
 
-    it "calls dor_fetcher_client.druid_array and then call :add on rsolr connection" do
+    it 'calls dor_fetcher_client.druid_array and then call :add on rsolr connection' do
       allow_any_instance_of(Harvestdor::Indexer::Resource).to receive(:collection?).and_return(false)
       expect(@indexer).to receive(:druids).and_return([@fake_druid])
       expect(@indexer.solr).to receive(:add).with(@doc_hash)
@@ -53,19 +67,19 @@ describe Harvestdor::Indexer do
       @indexer.harvest_and_index
     end
 
-    it "only calls :commit on rsolr connection once" do
+    it 'only calls :commit on rsolr connection once' do
       VCR.use_cassette('single_rsolr_connection_call') do
         hdor_client = @indexer.send(:harvestdor_client)
-        expect(@indexer.dor_fetcher_client).to receive(:druid_array).and_return(["druid:yg867hg1375", "druid:jf275fd6276", "druid:nz353cp1092", "druid:tc552kq0798", "druid:th998nk0722", "druid:ww689vs6534"])
-        expect(@indexer.solr).to receive(:add).exactly(6).times
+        expect(@indexer.dor_fetcher_client).to receive(:druid_array).and_return(['druid:yg867hg1375', 'druid:jf275fd6276', 'druid:nz353cp1092', 'druid:tc552kq0798', 'druid:th998nk0722', 'druid:ww689vs6534'])
+        expect(@indexer.solr).to receive(:add).at_least(6).times
         expect(@indexer.solr).to receive(:commit!).once
         @indexer.harvest_and_index
       end
     end
 
-    it "only processes druids in whitelist if it exists" do
+    it 'only processes druids in whitelist if it exists' do
       VCR.use_cassette('process_druids_whitelist_call') do
-        indexer = Harvestdor::Indexer.new(@config.merge(:whitelist => @whitelist_path))
+        indexer = described_class.new(@config.merge(whitelist: @whitelist_path))
         hdor_client = indexer.send(:harvestdor_client)
         added = []
         allow(indexer.solr).to receive(:add) { |hash|
@@ -73,56 +87,56 @@ describe Harvestdor::Indexer do
         }
         expect(indexer.solr).to receive(:commit!)
         indexer.harvest_and_index
-        expect(added).to match_array ["druid:tc552kq0798", "druid:th998nk0722", "druid:ww689vs6534", "druid:yg867hg1375", 'druid:jf275fd6276', 'druid:nz353cp1092']
+        expect(added).to include 'druid:tc552kq0798', 'druid:th998nk0722', 'druid:ww689vs6534', 'druid:yg867hg1375', 'druid:jf275fd6276', 'druid:nz353cp1092'
       end
     end
   end # harvest_and_index
 
   # Check for replacement of oai harvesting with dor-fetcher
-  context "replacing OAI harvesting with dor-fetcher" do
-      it "has a dor-fetcher client" do
-        expect(@indexer.dor_fetcher_client).to be_an_instance_of(DorFetcher::Client)
-      end
+  context 'replacing OAI harvesting with dor-fetcher' do
+    it 'has a dor-fetcher client' do
+      expect(@indexer.dor_fetcher_client).to be_an_instance_of(DorFetcher::Client)
+    end
 
-      it "druids method calls druid_array and get_collection methods on fetcher_client" do
-        VCR.use_cassette('get_collection_druids_call') do
-          expect(@indexer.resources.map(&:druid)).to match_array ["druid:yg867hg1375", "druid:jf275fd6276", "druid:nz353cp1092", "druid:tc552kq0798", "druid:th998nk0722", "druid:ww689vs6534"]
-        end
+    it 'druids method calls druid_array and get_collection methods on fetcher_client' do
+      VCR.use_cassette('get_collection_druids_call') do
+        expect(@indexer.resources.map(&:druid)).to include 'druid:yg867hg1375', 'druid:jf275fd6276', 'druid:nz353cp1092', 'druid:tc552kq0798', 'druid:th998nk0722', 'druid:ww689vs6534'
       end
+    end
 
-      it "gets the configuration of the dor-fetcher client from included yml file" do
-        expect(@indexer.dor_fetcher_client.service_url).to eq('http://127.0.0.1:3000')
-      end
+    it 'gets the configuration of the dor-fetcher client from included yml file' do
+      expect(@indexer.dor_fetcher_client.service_url).to eq('http://127.0.0.1:3000')
+    end
 
   end # ending replacing OAI context
 
-  context "whitelist" do
-    it "knows what is in the whitelist" do
+  context 'whitelist' do
+    it 'knows what is in the whitelist' do
       VCR.use_cassette('know_what_is_in_whitelist_call') do
-        lambda{
-          indexer = Harvestdor::Indexer.new({:whitelist => @whitelist_path})
-          expect(indexer.whitelist).to eq(["druid:yg867hg1375", "druid:jf275fd6276", "druid:nz353cp1092"])
+        lambda {
+          indexer = described_class.new({ whitelist: @whitelist_path })
+          expect(indexer.whitelist).to eq(['druid:yg867hg1375', 'druid:jf275fd6276', 'druid:nz353cp1092'])
         }
       end
     end
-    it "is an Array with an entry for each non-empty line in the file" do
+    it 'is an Array with an entry for each non-empty line in the file' do
       @indexer.send(:load_whitelist, @whitelist_path)
       expect(@indexer.send(:whitelist)).to be_an_instance_of(Array)
       expect(@indexer.send(:whitelist).size).to eq(3)
     end
-    it "is empty Array if there was no whitelist config setting" do
+    it 'is empty Array if there was no whitelist config setting' do
       VCR.use_cassette('empty_array_no_whitelist_config_call') do
-        lambda{
-          indexer = Harvestdor::Indexer.new()
+        lambda {
+          indexer = described_class.new
           expect(indexer.whitelist).to eq([])
         }
       end
     end
-    context "load_whitelist" do
-      it "is not called if there was no whitelist config setting" do
+    context 'load_whitelist' do
+      it 'is not called if there was no whitelist config setting' do
         VCR.use_cassette('no_whitelist_config_call') do
-          lambda{
-            indexer = Harvestdor::Indexer.new()
+          lambda {
+            indexer = described_class.new
 
             expect(indexer).not_to receive(:load_whitelist)
 
@@ -134,9 +148,9 @@ describe Harvestdor::Indexer do
           }
         end
       end
-      it "only try to load a whitelist once" do
+      it 'only try to load a whitelist once' do
         VCR.use_cassette('load_whitelist_once_call') do
-          indexer = Harvestdor::Indexer.new({:whitelist => @whitelist_path})
+          indexer = described_class.new({ whitelist: @whitelist_path })
           indexer.send(:whitelist)
           expect_any_instance_of(File).not_to receive(:open)
           indexer.send(:whitelist)
@@ -145,7 +159,7 @@ describe Harvestdor::Indexer do
       it "log an error message and throw RuntimeError if it can't find the indicated whitelist file" do
         VCR.use_cassette('cant_find_whitelist_call') do
           exp_msg = 'Unable to find list of druids at bad_path'
-          indexer = Harvestdor::Indexer.new(@config.merge(:whitelist => 'bad_path'))
+          indexer = described_class.new(@config.merge(whitelist: 'bad_path'))
           expect(indexer.logger).to receive(:fatal).with(exp_msg)
           expect { indexer.send(:load_whitelist, 'bad_path') }.to raise_error(exp_msg)
         end
@@ -153,17 +167,17 @@ describe Harvestdor::Indexer do
     end
   end # whitelist
 
-  it "solr_client initializes the rsolr client using the options from the config" do
+  it 'solr_client initializes the rsolr client using the options from the config' do
     VCR.use_cassette('rsolr_client_config_call') do
-      indexer = Harvestdor::Indexer.new(Confstruct::Configuration.new(solr: { url: 'http://localhost:2345', a: 1 }))
+      indexer = described_class.new(Confstruct::Configuration.new(solr: { url: 'http://localhost:2345', a: 1 }))
       expect(RSolr).to receive(:connect).with(hash_including(a: 1, url: 'http://localhost:2345'))
       indexer.solr
     end
   end
 
-  context "dor fetcher" do
-    it "skip_heartbeat allows me to use a fake url for dor-fetcher-client" do
-      expect {Harvestdor::Indexer.new()}.not_to raise_error
+  context 'dor fetcher' do
+    it 'skip_heartbeat allows me to use a fake url for dor-fetcher-client' do
+      expect { described_class.new }.not_to raise_error
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: harvestdor-indexer
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Naomi Dushay
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-26 00:00:00.000000000 Z
+date: 2015-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rsolr