gdor-indexer 0.1.0

data/spec/unit/solr_doc_builder_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe GDor::Indexer::SolrDocBuilder do
+  before(:all) do
+    @fake_druid = 'oo000oo0000'
+    @ns_decl = "xmlns='#{Mods::MODS_NS}'"
+    @mods_xml = "<mods #{@ns_decl}><note>SolrDocBuilder test</note></mods>"
+    @ng_mods_xml = Nokogiri::XML(@mods_xml)
+  end
+
+  let :logger do
+    Logger.new(StringIO.new)
+  end
+
+  def sdb_for_data(mods, pub_xml)
+    resource = Harvestdor::Indexer::Resource.new(double, @fake_druid)
+    allow(resource).to receive(:mods).and_return(Nokogiri::XML(mods))
+    allow(resource).to receive(:public_xml).and_return(Nokogiri::XML(pub_xml))
+    GDor::Indexer::SolrDocBuilder.new(resource, logger)
+  end
+
+  # NOTE:
+  # "Doubles, stubs, and message expectations are all cleaned out after each example."
+  # per https://www.relishapp.com/rspec/rspec-mocks/docs/scope
+
+  context 'doc_hash' do
+    before(:all) do
+      cmd_xml = "<contentMetadata type='image' objectId='#{@fake_druid}'></contentMetadata>"
+      @pub_xml = "<publicObject id='druid#{@fake_druid}'>#{cmd_xml}</publicObject>"
+    end
+    let :doc_hash do
+      sdb_for_data(@mods_xml, @pub_xml).doc_hash
+    end
+    before(:each) do
+      @doc_hash = doc_hash
+    end
+    it 'id field should be set to druid for non-merged record' do
+      expect(@doc_hash[:id]).to eq(@fake_druid)
+    end
+    it 'does not have the gdor fields set in indexer.rb' do
+      expect(@doc_hash).to_not have_key(:druid)
+      expect(@doc_hash).to_not have_key(:access_facet)
+      expect(@doc_hash).to_not have_key(:url_fulltext)
+      expect(@doc_hash).to_not have_key(:display_type)
+      expect(@doc_hash).to_not have_key(:file_id)
+    end
+    it 'has the full MODS in the modsxml field for non-merged record' do
+      expect(@doc_hash[:modsxml]).to be_equivalent_to @mods_xml
+    end
+  end # doc hash
+
+  context '#catkey' do
+    before(:all) do
+      @identity_md_start = "<publicObject><identityMetadata objectId='#{@fake_druid}'>"
+      @identity_md_end = '</identityMetadata></publicObject>'
+      @empty_id_md = "#{@identity_md_start}#{@identity_md_end}"
+      @barcode_id_md = "#{@identity_md_start}<otherId name=\"barcode\">666</otherId>#{@identity_md_end}"
+    end
+    it 'is nil if there is no indication of catkey in identityMetadata' do
+      sdb = sdb_for_data(@mods_xml, @empty_id_md)
+      expect(sdb.catkey).to be_nil
+    end
+    it 'takes a catkey in identityMetadata/otherId with name attribute of catkey' do
+      pub_xml = "#{@identity_md_start}<otherId name=\"catkey\">12345</otherId>#{@identity_md_end}"
+      sdb = sdb_for_data(@mods_xml, pub_xml)
+      expect(sdb.catkey).to eq('12345')
+    end
+    it 'is nil if there is no indication of catkey in identityMetadata even if there is a catkey in the mods' do
+      m = "<mods #{@ns_decl}><recordInfo>
+        <recordIdentifier source=\"SIRSI\">a6780453</recordIdentifier>
+      </recordInfo></mods>"
+      sdb = sdb_for_data(@mods_xml, @empty_id_md)
+      expect(sdb.catkey).to be_nil
+    end
+    it 'logs an error when there is identityMetadata/otherId with name attribute of barcode but there is no catkey in mods' do
+      sdb = sdb_for_data(@mods_xml, @barcode_id_md)
+      expect(logger).to receive(:error).with(/#{@fake_druid} has barcode .* in identityMetadata but no SIRSI catkey in mods/)
+      sdb.catkey
+    end
+
+    context 'catkey from mods' do
+      it 'looks for catkey in mods if identityMetadata/otherId with name attribute of barcode is found' do
+        sdb = sdb_for_data(@mods_xml, @barcode_id_md)
+        smr = sdb.smods_rec
+        expect(smr).to receive(:record_info).and_call_original # this is as close as I can figure to @smods_rec.record_info.recordIdentifier
+        sdb.catkey
+      end
+      it 'is nil if there is no catkey in the mods' do
+        m = "<mods #{@ns_decl}><recordInfo>
+          <descriptionStandard>dacs</descriptionStandard>
+        </recordInfo></mods>"
+        sdb = sdb_for_data(m, @barcode_id_md)
+
+        expect(sdb.catkey).to be_nil
+      end
+      it 'populated when source attribute is SIRSI' do
+        m = "<mods #{@ns_decl}><recordInfo>
+          <recordIdentifier source=\"SIRSI\">a6780453</recordIdentifier>
+        </recordInfo></mods>"
+        sdb = sdb_for_data(m, @barcode_id_md)
+        expect(sdb.catkey).not_to be_nil
+      end
+      it 'not populated when source attribute is not SIRSI' do
+        m = "<mods #{@ns_decl}><recordInfo>
+          <recordIdentifier source=\"FOO\">a6780453</recordIdentifier>
+        </recordInfo></mods>"
+        sdb = sdb_for_data(m, @barcode_id_md)
+        expect(sdb.catkey).to be_nil
+      end
+      it 'removes the a at the beginning of the catkey' do
+        m = "<mods #{@ns_decl}><recordInfo>
+          <recordIdentifier source=\"SIRSI\">a6780453</recordIdentifier>
+        </recordInfo></mods>"
+        sdb = sdb_for_data(m, @barcode_id_md)
+        expect(sdb.catkey).to eq('6780453')
+      end
+    end
+  end # #catkey
+
+  context 'using Harvestdor::Client' do
+    context '#smods_rec (called in initialize method)' do
+      it 'returns Stanford::Mods::Record object' do
+        sdb = sdb_for_data(@mods_xml, nil)
+        expect(sdb.smods_rec).to be_an_instance_of(Stanford::Mods::Record)
+      end
+    end
+  end # context using Harvestdor::Client
+end

data/spec/unit/solr_doc_hash_spec.rb

@@ -0,0 +1,399 @@
+require 'spec_helper'
+
+describe GDor::Indexer::SolrDocHash do
+  context '#field_present?' do
+    context 'actual field value is boolean true' do
+      subject do
+        described_class.new(a: true)
+      end
+      it 'true if expected value is nil' do
+        expect(subject).to be_field_present(:a)
+      end
+      it 'false if expected value is String' do
+        expect(subject).not_to be_field_present(:a, 'true')
+      end
+      it 'false if expected value is Regex' do
+        expect(subject).not_to be_field_present(a: /true/)
+      end
+    end
+
+    context 'expected value is nil' do
+      subject { described_class.new({}) }
+      it 'false if the field is not in the doc_hash' do
+        expect(subject).not_to be_field_present(:any)
+      end
+      it 'false if hash[field] is nil' do
+        subject[:foo] = nil
+        expect(subject).not_to be_field_present(:foo)
+      end
+      it 'false if hash[field] is an empty String' do
+        subject[:foo] = ''
+        expect(subject).not_to be_field_present(:foo)
+      end
+      it 'true if hash[field] is a non-empty String' do
+        subject[:foo] = 'bar'
+        expect(subject).to be_field_present(:foo)
+      end
+      it 'false if hash[field] is an empty Array' do
+        subject[:foo] = []
+        expect(subject).not_to be_field_present(:foo)
+      end
+      it 'false if hash[field] is an Array with only empty String values' do
+        subject[:foo] = ['', '']
+        expect(subject).not_to be_field_present(:foo)
+      end
+      it 'false if hash[field] is an Array with only nil String values' do
+        subject[:foo] = [nil]
+        expect(subject).not_to be_field_present(:foo)
+      end
+      it 'true if hash[field] is a non-empty Array' do
+        subject[:foo] = ['a']
+        expect(subject).to be_field_present(:foo)
+      end
+      it 'false if doc_hash[field] is not a String or Array' do
+        subject[:foo] = {}
+        expect(subject).not_to be_field_present(:foo)
+      end
+    end
+
+    context 'expected value is a String' do
+      subject { described_class.new({}) }
+
+      it 'true if hash[field] is a String and matches' do
+        subject[:foo] = 'a'
+        expect(subject).to be_field_present(:foo, 'a')
+      end
+      it "false if hash[field] is a String and doesn't match" do
+        subject[:foo] = 'a'
+        expect(subject).not_to be_field_present(:foo, 'b')
+      end
+      it 'true if hash[field] is an Array with a value that matches' do
+        subject[:foo] = %w(a b)
+        expect(subject).to be_field_present(:foo, 'a')
+      end
+      it 'false if hash[field] is an Array with no value that matches' do
+        subject[:foo] = %w(a b)
+        expect(subject).not_to be_field_present(:foo, 'c')
+      end
+      it 'false if hash[field] is not a String or Array' do
+        subject[:foo] = {}
+        expect(subject).not_to be_field_present(:foo, 'a')
+      end
+    end
+
+    context 'expected value is Regex' do
+      subject { described_class.new({}) }
+
+      it 'true if hash[field] is a String and matches' do
+        subject[:foo] = 'aba'
+        expect(subject).to be_field_present(:foo, /b/)
+      end
+      it "false if hash[field] is a String and doesn't match" do
+        subject[:foo] = 'aaaaa'
+        expect(subject).not_to be_field_present(:foo, /b/)
+      end
+      it 'true if hash[field] is an Array with a value that matches' do
+        subject[:foo] = %w(a b)
+        expect(subject).to be_field_present(:foo, /b/)
+      end
+      it 'false if hash[field] is an Array with no value that matches' do
+        subject[:foo] = %w(a b)
+        expect(subject).not_to be_field_present(:foo, /c/)
+      end
+      it 'false if hash[field] is not a String or Array' do
+        subject[:foo] = {}
+        expect(subject).not_to be_field_present(:foo, /a/)
+      end
+    end
+  end # field_present?
+
+  context '#combine' do
+    context 'orig has no key' do
+      subject do
+        described_class.new({})
+      end
+
+      it 'result has no key if new value is nil' do
+        expect(subject.combine(foo: nil)).to eq({})
+      end
+      it 'result has no key if new value is empty String' do
+        expect(subject.combine(foo: '')).to eq({})
+      end
+      it 'result has new value if new value is non-empty String' do
+        expect(subject.combine(foo: 'bar')).to eq(foo: 'bar')
+      end
+      it 'result has no key if new value is empty Array' do
+        expect(subject.combine(foo: [])).to eq({})
+      end
+      it 'result has new value new value is non-empty Array' do
+        expect(subject.combine(foo: ['bar'])).to eq(foo: ['bar'])
+      end
+      it 'result has no key if new value is not String or Array' do
+        expect(subject.combine(foo: {})).to eq({})
+      end
+    end # orig has no key
+    context 'orig value is nil' do
+      subject do
+        described_class.new(foo: nil)
+      end
+      it 'result has no key if new value is nil' do
+        expect(subject.combine(foo: nil)).to eq({})
+      end
+      it 'result has no key if new value is empty String' do
+        expect(subject.combine(foo: '')).to eq({})
+      end
+      it 'result has new value if new value is non-empty String' do
+        expect(subject.combine(foo: 'bar')).to eq(foo: 'bar')
+      end
+      it 'result has no key if new value is empty Array' do
+        expect(subject.combine(foo: [])).to eq({})
+      end
+      it 'result has new value if new value is non-empty Array' do
+        expect(subject.combine(foo: ['bar'])).to eq(foo: ['bar'])
+      end
+      it 'result has no key if new value is not String or Array' do
+        expect(subject.combine(foo: {})).to eq({})
+      end
+    end # orig value is nil
+    context 'orig value is empty String' do
+      subject do
+        described_class.new(foo: '')
+      end
+      it 'result has no key if new value is nil' do
+        expect(subject.combine(foo: nil)).to eq({})
+      end
+      it 'result has no key if new value is empty String' do
+        expect(subject.combine(foo: '')).to eq({})
+      end
+      it 'result has new value if new value is non-empty String' do
+        expect(subject.combine(foo: 'bar')).to eq(foo: 'bar')
+      end
+      it 'result has no key if new value is empty Array' do
+        expect(subject.combine(foo: [])).to eq({})
+      end
+      it 'result has new value if new value is non-empty Array' do
+        expect(subject.combine(foo: ['bar'])).to eq(foo: ['bar'])
+      end
+      it 'result has no key if new value is not String or Array' do
+        expect(subject.combine(foo: {})).to eq({})
+      end
+    end # orig value is empty String
+    context 'orig value is non-empty String' do
+      subject do
+        described_class.new(foo: 'a')
+      end
+      it 'result is orig value if new value is nil' do
+        expect(subject.combine(foo: nil)).to eq(foo: 'a')
+      end
+      it 'result is orig value if new value is empty String' do
+        expect(subject.combine(foo: '')).to eq(foo: 'a')
+      end
+      it 'result is Array of old and new values if new value is non-empty String' do
+        expect(subject.combine(foo: 'bar')).to eq(foo: %w(a bar))
+      end
+      it 'result is orig value if new value is empty Array' do
+        expect(subject.combine(foo: [])).to eq(foo: 'a')
+      end
+      it 'result Array of old and new values if new value is non-empty Array' do
+        expect(subject.combine(foo: %w(bar ness))).to eq(foo: %w(a bar ness))
+      end
+      it 'result is orig value if new value is not String or Array' do
+        expect(subject.combine(foo: :bar)).to eq(foo: ['a', :bar])
+      end
+    end # orig value is String
+    context 'orig value is empty Array' do
+      subject do
+        described_class.new(foo: [])
+      end
+      it 'result has no key if new value is nil' do
+        expect(subject.combine(foo: nil)).to eq({})
+      end
+      it 'result has no key if new value is empty String' do
+        expect(subject.combine(foo: '')).to eq({})
+      end
+      it 'result is new value if new value is non-empty String' do
+        expect(subject.combine(foo: 'bar')).to eq(foo: 'bar')
+      end
+      it 'result has no key if new value is empty Array' do
+        expect(subject.combine(foo: [])).to eq({})
+      end
+      it 'result is new values if new value is non-empty Array' do
+        expect(subject.combine(foo: %w(bar ness))).to eq(foo: %w(bar ness))
+      end
+      it 'result has no key if new value is not String or Array' do
+        expect(subject.combine(foo: {})).to eq({})
+      end
+    end # orig value is empty Array
+    context 'orig value is non-empty Array' do
+      subject do
+        described_class.new(foo: %w(a b))
+      end
+      it 'result is orig value if new value is nil' do
+        expect(subject.combine(foo: nil)).to eq(foo: %w(a b))
+      end
+      it 'result is orig value if new value is empty String' do
+        expect(subject.combine(foo: '')).to eq(foo: %w(a b))
+      end
+      it 'result is Array of old and new values if new value is non-empty String' do
+        expect(subject.combine(foo: 'bar')).to eq(foo: %w(a b bar))
+      end
+      it 'result is orig value if new value is empty Array' do
+        expect(subject.combine(foo: [])).to eq(foo: %w(a b))
+      end
+      it 'result Array of old and new values if new value is non-empty Array' do
+        expect(subject.combine(foo: %w(bar ness))).to eq(foo: %w(a b bar ness))
+      end
+      it 'result is orig value if new value is not String or Array' do
+        expect(subject.combine(foo: :bar)).to eq(foo: ['a', 'b', :bar])
+      end
+    end # orig value is non-empty Array
+  end # combine
+
+  context '#validate_item' do
+    let(:collection_druid) { 'xyz' }
+    let(:mock_config) { Confstruct::Configuration.new }
+
+    before do
+      described_class.any_instance.stub(validate_gdor_fields: [])
+    end
+
+    it 'calls validate_gdor_fields' do
+      hash = described_class.new({})
+      expect(hash).to receive(:validate_gdor_fields).and_return([])
+      hash.validate_item(mock_config)
+    end
+    it 'has a value if collection is wrong' do
+      hash = described_class.new(collection: 'junk',
+                                 collection_with_title: "#{collection_druid}-|-asdasdf",
+                                 file_id: ['anything'])
+      expect(hash).to receive(:validate_gdor_fields).and_return([])
+      expect(hash.validate_item(mock_config).first).to match(/collection /)
+    end
+    it 'has a value if collection_with_title is missing' do
+      hash = described_class.new(collection: collection_druid,
+                                 collection_with_title: nil,
+                                 file_id: ['anything'])
+      expect(hash.validate_item(mock_config).first).to match(/collection_with_title /)
+    end
+    it 'has a value if collection_with_title is missing the title' do
+      hash = described_class.new(collection: collection_druid,
+                                 collection_with_title: "#{collection_druid}-|-",
+                                 file_id: ['anything'])
+      expect(hash.validate_item(mock_config).first).to match(/collection_with_title /)
+    end
+    it 'has a value if file_id field is missing' do
+      hash = described_class.new(collection: collection_druid,
+                                 collection_with_title: "#{collection_druid}-|-asdasdf",
+                                 file_id: nil)
+      expect(hash.validate_item(mock_config).first).to match(/file_id/)
+    end
+    it 'does not have a value if gdor_fields and item fields are ok' do
+      hash = described_class.new(collection: collection_druid,
+                                 collection_with_title: "#{collection_druid}-|-asdasdf",
+                                 file_id: ['anything'])
+      expect(hash.validate_item(mock_config)).to eq([])
+    end
+  end # validate_item
+
+  context '#validate_collection' do
+    let(:mock_config) { Confstruct::Configuration.new }
+
+    before do
+      described_class.any_instance.stub(validate_gdor_fields: [])
+    end
+
+    it 'calls validate_gdor_fields' do
+      hash = described_class.new({})
+      expect(hash).to receive(:validate_gdor_fields).and_return([])
+      hash.validate_collection(mock_config)
+    end
+    it 'has a value if collection_type is missing' do
+      hash = described_class.new(format_main_ssim: 'Archive/Manuscript')
+
+      expect(hash.validate_collection(mock_config).first).to match(/collection_type/)
+    end
+    it "has a value if collection_type is not 'Digital Collection'" do
+      hash = described_class.new(collection_type: 'lalalalala', format_main_ssim: 'Archive/Manuscript')
+      expect(hash.validate_collection(mock_config).first).to match(/collection_type/)
+    end
+    it 'has a value if format_main_ssim is missing' do
+      hash = described_class.new(collection_type: 'Digital Collection')
+      expect(hash.validate_collection(mock_config).first).to match(/format_main_ssim/)
+    end
+    it "has a value if format_main_ssim doesn't include 'Archive/Manuscript'" do
+      hash = described_class.new(format_main_ssim: 'lalalalala', collection_type: 'Digital Collection')
+      expect(hash.validate_collection(mock_config).first).to match(/format_main_ssim/)
+    end
+    it 'does not have a value if gdor_fields, collection_type and format_main_ssim are ok' do
+      hash = described_class.new(collection_type: 'Digital Collection', format_main_ssim: 'Archive/Manuscript')
+      expect(hash.validate_collection(mock_config)).to eq([])
+    end
+  end # validate_collection
+
+  context '#validate_gdor_fields' do
+    let(:druid) { 'druid' }
+    let(:purl_url) { mock_config.harvestdor.purl }
+    let(:mock_config) do
+      Confstruct::Configuration.new do
+        harvestdor do
+          purl 'https://some.uri'
+        end
+      end
+    end
+
+    it 'returns an empty Array when there are no problems' do
+      hash = described_class.new(access_facet: 'Online',
+                                 druid: druid,
+                                 url_fulltext: "#{purl_url}/#{druid}",
+                                 display_type: 'image',
+                                 building_facet: 'Stanford Digital Repository')
+      expect(hash.validate_gdor_fields(mock_config)).to eq([])
+    end
+    it 'has a value for each missing field' do
+      hash = described_class.new({})
+      expect(hash.validate_gdor_fields(mock_config).length).to eq(5)
+    end
+    it 'has a value for an unrecognized display_type' do
+      hash = described_class.new(access_facet: 'Online',
+                                 druid: druid,
+                                 url_fulltext: "#{purl_url}/#{druid}",
+                                 display_type: 'zzzz',
+                                 building_facet: 'Stanford Digital Repository')
+      expect(hash.validate_gdor_fields(mock_config).first).to match(/display_type/)
+    end
+    it "has a value for access_facet other than 'Online'" do
+      hash = described_class.new(access_facet: 'BAD',
+                                 druid: druid,
+                                 url_fulltext: "#{purl_url}/#{druid}",
+                                 display_type: 'image',
+                                 building_facet: 'Stanford Digital Repository')
+      expect(hash.validate_gdor_fields(mock_config).first).to match(/access_facet/)
+    end
+    it "has a value for building_facet other than 'Stanford Digital Repository'" do
+      hash = described_class.new(access_facet: 'Online',
+                                 druid: druid,
+                                 url_fulltext: "#{purl_url}/#{druid}",
+                                 display_type: 'image',
+                                 building_facet: 'WRONG')
+      expect(hash.validate_gdor_fields(mock_config).first).to match(/building_facet/)
+    end
+  end # validate_gdor_fields
+
+  context '#validation_mods' do
+    let(:mock_config) { {} }
+    it 'has no validation messages for a complete record' do
+      hash = described_class.new(modsxml: 'whatever',
+                                 title_display: 'title',
+                                 pub_year_tisim: 'some year',
+                                 author_person_display: 'author',
+                                 format_main_ssim: 'Image',
+                                 format: 'Image',
+                                 language: 'English')
+      expect(hash.validate_mods(mock_config).length).to eq(0)
+    end
+    it 'has validation messages for each missing field' do
+      hash = described_class.new(id: 'whatever')
+      expect(hash.validate_mods(mock_config).length).to eq(7)
+    end
+  end
+end