pennmarc 0.0.1

data/spec/lib/pennmarc/helpers/subject_spec.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+describe 'PennMARC::Subject' do
+  include MarcSpecHelpers
+
+  let(:helper) { PennMARC::Subject }
+  let(:relator_map) do
+    { dpc: 'Depicted' }
+  end
+
+  describe '.search' do
+    let(:record) { marc_record fields: fields }
+    let(:values) { helper.search(record, relator_map) }
+
+    context 'with a mix of included and excluded tags' do
+      let(:fields) do
+        [marc_field(tag: '600', indicator2: '5', subfields: { a: 'Excluded Canadian' }),
+         marc_field(tag: '610', indicator2: '0', subfields: { a: 'University of Pennsylvania', b: 'Libraries' }),
+         marc_field(tag: '691', indicator2: '7', subfields: { a: 'Van Pelt Library', '2': 'local' }),
+         marc_field(tag: '696', indicator2: '4', subfields: { a: 'A Developer' }),
+         marc_field(tag: '880', indicator2: '0', subfields: { a: 'Alt. Name', '6': '610' })]
+      end
+
+      it 'includes only values from valid tags' do
+        expect(values).to contain_exactly 'A Developer', 'Alt. Name', 'University of Pennsylvania Libraries',
+                                          'Van Pelt Library local'
+        expect(values).not_to include 'Excluded Canadian'
+      end
+    end
+
+    context 'with PRO/CHR values in sf a' do
+      let(:fields) do
+        [marc_field(tag: '650', indicator2: '4', subfields: { a: 'PRO Subject' }),
+         marc_field(tag: '650', indicator2: '4', subfields: { a: '%CHR Heading' })]
+      end
+
+      it 'removes the PRO/CHR designation' do
+        expect(values).to contain_exactly 'Subject', 'Heading'
+      end
+    end
+
+    context 'with a question mark at the end of sf a' do
+      let(:fields) do
+        [marc_field(tag: '650', indicator2: '4', subfields: { a: 'Potential Subject?' })]
+      end
+
+      it 'removes the question mark' do
+        expect(values).to contain_exactly 'Potential Subject'
+      end
+    end
+
+    context 'with a relator code specified' do
+      let(:fields) do
+        [marc_field(tag: '650', indicator2: '4', subfields: { a: 'Unicorns', '4': 'dpc' })]
+      end
+
+      it 'includes both the relator code and the mapped value, if found' do
+        expect(values.first).to eq 'Unicorns dpc Depicted'
+      end
+    end
+  end
+
+  describe '.facet' do
+    let(:record) { marc_record fields: }
+    let(:values) { helper.facet(record) }
+
+    # TODO: find some more inspiring examples in the corpus
+    context 'for a record with poorly-coded heading values' do
+      let(:fields) { [marc_field(tag: '650', indicator2: '0', subfields: { a: 'Subject -   Heading' })] }
+
+      it 'properly normalizes the heading value' do
+        expect(values.first).to eq 'Subject--Heading'
+      end
+    end
+
+    context 'for a record with 650 headings with a ǂa that starts with PRO or CHR' do
+      let(:fields) do
+        [marc_field(tag: '650', indicator2: '4', subfields: { a: '%CHR 1998', '5': 'PU' }),
+         marc_field(tag: '650', indicator2: '4', subfields: { a: 'PRO Potok, Adena (donor) (Potok Collection copy)',
+                                                              '5': 'PU' })]
+      end
+
+      it 'does not include the headings' do
+        expect(values).to be_empty
+      end
+    end
+
+    context 'for a record with an indicator2 value of 3, 5 or 6' do
+      let(:fields) do
+        [marc_field(tag: '650', indicator2: '3', subfields: { a: 'Nope' }),
+         marc_field(tag: '650', indicator2: '5', subfields: { a: 'Nope' }),
+         marc_field(tag: '650', indicator2: '6', subfields: { a: 'Nope' })]
+      end
+
+      it 'does not include the headings' do
+        expect(values).to be_empty
+      end
+    end
+
+    context 'for a record with a valid tag, indicator2 and source specified' do
+      let(:fields) do
+        [marc_field(tag: '650', indicator2: '7',
+                    subfields: {
+                      a: 'Libraries', x: 'History', e: 'relator', d: '22nd Century',
+                      '2': 'fast', '0': 'http://fast.org/libraries'
+                    })]
+      end
+
+      it 'properly concatenates heading components' do
+        expect(values.first).to include 'Libraries--History'
+      end
+
+      it 'excludes URI values from ǂ0 or ǂ1' do
+        expect(values.first).not_to include 'http'
+      end
+
+      it 'excludes raw relator term values from ǂe' do
+        expect(values.first).not_to include 'relator'
+      end
+
+      it 'includes active dates from ǂd' do
+        expect(values.first).to include '22nd Century'
+      end
+
+      it 'joins all values in the expected way' do
+        expect(values.first).to eq 'Libraries--History 22nd Century'
+      end
+    end
+  end
+
+  describe '.show' do
+    let(:record) { marc_record fields: }
+    let(:values) { helper.facet(record) }
+
+    context 'with a variety of headings' do
+      let(:fields) do
+        [marc_field(tag: '650', indicator2: '0', subfields: { a: 'Nephrology', v: 'Periodicals' }),
+         marc_field(tag: '650', indicator2: '7',
+                    subfields: { a: 'Nephrology', '2': 'fast', '0': '(OCoLC)fst01035991' }),
+         marc_field(tag: '650', indicator2: '7', subfields: { a: 'Undesirable Heading', '2': 'exclude' }),
+         marc_field(tag: '650', indicator2: '2', subfields: { a: 'Nephrology' }),
+         marc_field(tag: '650', indicator2: '1', subfields: { a: 'Kidney Diseases' }),
+         marc_field(tag: '690', subfields: { a: 'Local Heading' }),
+         marc_field(tag: '690', subfields: { a: 'Local Heading' })]
+      end
+
+      it 'shows all valid subject headings without duplicates' do
+        expect(helper.show(record)).to match_array ['Nephrology--Periodicals', 'Nephrology',
+                                                    'Kidney Diseases', 'Local Heading']
+      end
+    end
+
+    context 'with a robust 650 heading including many subfields' do
+      let(:fields) do
+        [marc_field(tag: '650', indicator2: '0', subfields: {
+                      a: 'Subways',
+                      z: ['Pennsylvania', 'Philadelphia Metropolitan Area'],
+                      v: 'Maps',
+                      y: '1989',
+                      e: 'relator'
+                    })]
+      end
+
+      it 'properly formats the heading parts' do
+        expect(values.first).to eq 'Subways--Pennsylvania--Philadelphia Metropolitan Area--Maps--1989'
+        expect(values.first).not_to include 'relator'
+      end
+    end
+
+    context 'with a robust 651 heading including many subfields' do
+      let(:fields) do
+        [marc_field(tag: '651', indicator2: '4', subfields: {
+                      a: 'Chicago (Ill.)',
+                      x: 'Moral conditions',
+                      '3': 'Church minutes',
+                      y: '1875-1878',
+                      '0': 'http://some.uri/zzz'
+                    })]
+      end
+
+      it 'properly formats the heading parts' do
+        expect(values.first).to eq 'Chicago (Ill.)--Moral conditions--Church minutes--1875-1878'
+      end
+    end
+
+    context 'with a robust 611 heading including many subfields' do
+      let(:fields) do
+        [marc_field(tag: '611', indicator2: '0', subfields: {
+                      a: 'Conference',
+                      d: '(2002',
+                      n: '2nd',
+                      c: ['Johannesburg, South Africa', 'Cape Town, South Africa)']
+                    })]
+      end
+
+      it 'properly formats the heading parts' do
+        expect(values.first).to eq 'Conference--2nd (2002 Johannesburg, South Africa Cape Town, South Africa)'
+      end
+    end
+
+    context 'with a robust 600 heading including many subfields' do
+      let(:fields) do
+        [marc_field(tag: '600', indicator2: '0', subfields: {
+                      a: 'Person, Significant Author',
+                      d: '1899-1971',
+                      v: 'Early works to 1950',
+                      t: 'Collection'
+                    })]
+      end
+
+      it 'properly formats the heading parts' do
+        expect(values.first).to eq 'Person, Significant Author--Early works to 1950 1899-1971 Collection'
+      end
+    end
+  end
+
+  describe '.childrens_show' do
+    let(:record) do
+      marc_record(fields: [
+                    marc_field(tag: '650', indicator2: '1', subfields: { a: 'Frogs', v: 'Fiction' }),
+                    marc_field(tag: '650', indicator2: '1', subfields: { a: 'Toads', v: 'Fiction' }),
+                    marc_field(tag: '650', indicator2: '2', subfields: { a: 'Herpetology' })
+                  ])
+    end
+    let(:values) { helper.childrens_show(record) }
+
+    it 'includes heading terms only from subject tags with an indicator 2 of "1"' do
+      expect(values).to contain_exactly 'Frogs--Fiction', 'Toads--Fiction'
+    end
+  end
+
+  describe '.medical_show' do
+    let(:record) do
+      marc_record(
+        fields: [
+          marc_field(tag: '650', indicator2: '0', subfields: { a: 'Nephhrology', v: 'Periodicals' }),
+          marc_field(tag: '650', indicator2: '7',
+                     subfields: { a: 'Nephhrology', '2': 'fast', '0': '(OCoLC)fst01035991' }),
+          marc_field(tag: '650', indicator2: '2', subfields: { a: 'Nephrology' }),
+          marc_field(tag: '650', indicator2: '1', subfields: { a: 'Kidney Diseases' })
+        ]
+      )
+    end
+
+    it 'includes heading terms only from subject tags with indicator 2 of "2"' do
+      expect(helper.medical_show(record)).to contain_exactly 'Nephrology'
+    end
+  end
+
+  describe '.local_show' do
+    let(:record) do
+      marc_record(fields: [
+                    marc_field(tag: '650', indicator2: '4', subfields: { a: 'Local', v: 'Heading' }),
+                    marc_field(tag: '690', indicator2: '4', subfields: { a: 'Super Local.' })
+                  ])
+    end
+
+    it 'includes heading terms only from subject tags with indicator 2 of "4" or in the 69X range' do
+      expect(helper.local_show(record)).to contain_exactly 'Local--Heading', 'Super Local.'
+    end
+  end
+end

data/spec/lib/pennmarc/helpers/title_spec.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+describe 'PennMARC::Title' do
+  include MarcSpecHelpers
+
+  let(:helper) { PennMARC::Title }
+
+  describe '.search' do
+    let(:record) do
+      marc_record fields: [
+        marc_field(tag: '245', subfields: { a: 'Title', b: 'Subtitle', c: 'Responsibility', h: 'Medium' }),
+        marc_field(tag: '880', subfields: { a: 'Linked Title', '6': '245' })
+      ]
+    end
+
+    it 'returns search values without ǂc or ǂh content' do
+      values = helper.search(record)
+      expect(values).to contain_exactly 'Linked Title', 'Title Subtitle'
+      expect(values).not_to include 'Responsibility', 'Medium'
+    end
+  end
+
+  xdescribe '.search_aux'
+
+  describe '.show' do
+    let(:record) { marc_record fields: [marc_field(tag: '245', subfields: subfields)] }
+
+    context 'with ǂa, ǂk and ǂn defined' do
+      let(:subfields) { { a: 'Five Decades of MARC usage', k: 'journals', n: 'Part One' } }
+
+      it 'returns single title value with text from ǂa and ǂn but not ǂk' do
+        expect(helper.show(record)).to eq 'Five Decades of MARC usage Part One'
+      end
+    end
+
+    context 'with no ǂa but a ǂk and ǂn defined' do
+      let(:subfields) { { k: 'journals', n: 'Part One' } }
+
+      it 'returns single title value with text from ǂk and ǂn' do
+        expect(helper.show(record)).to eq 'journals Part One'
+      end
+    end
+
+    context 'with ǂa containing an " = "' do
+      let(:subfields) { { a: 'There is a parallel statement = ', b: 'Parallel statement / ' } }
+
+      it 'returns single title value with text from ǂa and ǂb joined with an " = " and other trailing punctuation
+          removed' do
+        expect(helper.show(record)).to eq 'There is a parallel statement = Parallel statement'
+      end
+    end
+
+    context 'with ǂa containing an " : "' do
+      let(:subfields) { { a: 'There is an other statement : ', b: 'Other statement' } }
+
+      it 'returns single title value with text from ǂa and ǂn' do
+        expect(helper.show(record)).to eq 'There is an other statement : Other statement'
+      end
+    end
+  end
+
+  describe '.sort' do
+    context 'with a record with a valid indicator2 value' do
+      let(:record) do
+        marc_record fields: [
+          marc_field(tag: '245', indicator2: '4', subfields: {
+                       a: 'The Record Title',
+                       b: 'Remainder', n: 'Number', p: 'Section',
+                       h: 'Do not display'
+                     })
+        ]
+      end
+
+      it 'properly removes and appends the number of characters specified in indicator 2' do
+        value = helper.sort(record)
+        expect(value).to start_with 'Record Title'
+        expect(value).to end_with 'The'
+      end
+
+      it 'includes ǂb, ǂn and ǂp values' do
+        expect(helper.sort(record)).to eq 'Record Title Remainder Number Section The'
+      end
+    end
+
+    context 'with a record with no indicator2 value' do
+      let(:record) do
+        marc_record fields: [marc_field(tag: '245', subfields: { a: 'The Record Title' })]
+      end
+
+      it 'does not transform the title value' do
+        expect(helper.sort(record)).to eq 'The Record Title'
+      end
+    end
+
+    context 'with a record with no ǂa and no indicator2 value' do
+      let(:record) do
+        marc_record fields: [marc_field(tag: '245', subfields: { k: 'diaries' })]
+      end
+
+      it 'uses ǂk (form) value without transformation' do
+        expect(helper.sort(record)).to eq 'diaries'
+      end
+    end
+
+    context 'with a record with a leading bracket' do
+      let(:record) do
+        marc_record fields: [marc_field(tag: '245', subfields: { a: '[The Record Title]' })]
+      end
+
+      # TODO: is this the expected behavior? It would sort right, but looks silly.
+      it 'removes the leading bracket and appends it to the full value' do
+        expect(helper.sort(record)).to eq 'The Record Title] ['
+      end
+    end
+  end
+
+  describe '.standardized' do
+    let(:record) do
+      marc_record fields: [
+        marc_field(tag: '130', subfields: { a: 'Uniform Title', f: '2000', '8': 'Not Included' }),
+        marc_field(tag: '240', subfields: { a: 'Another Uniform Title', '0': 'Ugly Control Number' }),
+        marc_field(tag: '730', indicator2: '', subfields: { a: 'Yet Another Uniform Title' }),
+        marc_field(tag: '730', indicator1: '0', indicator2: '2', subfields: { a: 'Not Printed Title' }),
+        marc_field(tag: '730', indicator1: '', subfields: { i: 'Subfield i Title' }),
+        marc_field(tag: '880', subfields: { '6': '240', a: 'Translated Uniform Title' })
+      ]
+    end
+
+    it 'returns the expected standardized title display values' do
+      values = helper.standardized(record)
+      expect(values).to contain_exactly(
+        'Another Uniform Title', 'Translated Uniform Title', 'Uniform Title 2000', 'Yet Another Uniform Title'
+      )
+      expect(values).not_to include 'Not Printed Title', 'Subfield i Title'
+    end
+  end
+
+  describe '.other' do
+    let(:record) do
+      marc_record fields: [
+        marc_field(tag: '246', subfields: { a: 'Varied Title', f: '2000', '8': 'Not Included' }),
+        marc_field(tag: '740', indicator2: '0', subfields: { a: 'Uncontrolled Title', '5': 'Penn' }),
+        marc_field(tag: '740', indicator2: '2', subfields: { a: 'A Title We Do Not Like' }),
+        marc_field(tag: '880', subfields: { '6': '246', a: 'Alternate Varied Title' })
+      ]
+    end
+
+    it 'returns the expected other title display values' do
+      expect(helper.other(record)).to contain_exactly(
+        'Alternate Varied Title', 'Uncontrolled Title', 'Varied Title 2000'
+      )
+    end
+  end
+
+  describe '.former' do
+    let(:record) do
+      marc_record fields: [
+        marc_field(tag: '247', subfields: { a: 'Former Title', n: 'Part', '6': 'Linkage', e: 'Append' }),
+        marc_field(tag: '880', subfields: { a: 'Alt Title', n: 'Part', '6': '247' })
+      ]
+    end
+
+    it 'returns the expected former title value' do
+      values = helper.former(record)
+      expect(values).to contain_exactly 'Former Title Part Append', 'Alt Title Part'
+      expect(values).not_to include 'Linkage', '247'
+    end
+  end
+end

data/spec/lib/pennmarc/marc_util_spec.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+describe 'PennMARC::Util' do
+  include MarcSpecHelpers
+
+  subject(:util) do
+    Class.new { extend PennMARC::Util }
+  end
+
+  describe '.join_subfields' do
+    let(:field) { marc_field subfields: { a: 'bad', '1': 'join', '3': '', '9': 'subfields' } }
+
+    it 'joins subfield values after selecting values using a block' do
+      subfield_numeric = ->(subfield) { subfield.code =~ /[0-9]/ }
+      expect(util.join_subfields(field, &subfield_numeric)).to eq 'join subfields'
+    end
+  end
+
+  describe '.subfield_value?' do
+    let(:field) { marc_field subfields: { a: '123' } }
+
+    it 'returns true if the specified subfield value matches the regex' do
+      expect(util.subfield_value?(field, 'a', /123/)).to be_truthy
+    end
+
+    it 'returns false if the subfield value does not match the regex' do
+      expect(util.subfield_value?(field, 'a', /\D/)).to be_falsey
+    end
+  end
+
+  describe '.subfield_value_in?' do
+    let(:field) { marc_field subfields: { a: '123' } }
+
+    it 'returns true if value is in array' do
+      expect(util.subfield_value_in?(field, 'a', ['123'])).to be true
+    end
+  end
+
+  describe '.subfield_in?' do
+    it 'returns a lambda that checks if a subfield code is a member of the array' do
+      array = %w[a b c]
+      subfield_in = util.subfield_in?(array)
+
+      subfield = marc_subfield('a', 'Value')
+      expect(subfield_in.call(subfield)).to be_truthy
+
+      subfield = marc_subfield('d', 'Value')
+      expect(subfield_in.call(subfield)).to be_falsey
+    end
+  end
+
+  describe '#subfield_not_in?' do
+    it 'returns a lambda that checks if a subfield code is not a member of the array' do
+      array = %w[a b c]
+      subfield_not_in = util.subfield_not_in?(array)
+
+      subfield = marc_subfield('a', 'Value')
+      expect(subfield_not_in.call(subfield)).to be_falsey
+
+      subfield = marc_subfield('d', 'Value')
+      expect(subfield_not_in.call(subfield)).to be_truthy
+    end
+  end
+
+  describe '.subfield_defined?' do
+    let(:field) { marc_field subfields: { a: 'Defined' } }
+
+    it 'returns true if subfield is present on a field' do
+      expect(util.subfield_defined?(field, :a)).to be_truthy
+      expect(util.subfield_defined?(field, 'a')).to be_truthy
+    end
+
+    it 'returns false if a subfield is not present on a field' do
+      expect(util.subfield_defined?(field, :b)).to be_falsey
+    end
+  end
+
+  describe '.subfield_undefined?' do
+    let(:field) { marc_field subfields: { a: 'Defined' } }
+
+    it 'returns true if subfield is not present on a field' do
+      expect(util.subfield_undefined?(field, :b)).to be_truthy
+      expect(util.subfield_undefined?(field, 'b')).to be_truthy
+    end
+
+    it 'returns false if a subfield is present on a field' do
+      expect(util.subfield_undefined?(field, :a)).to be_falsey
+    end
+  end
+
+  describe '.subfield_values' do
+    let(:field) { marc_field subfields: { a: %w[A B C], b: 'Not Included' } }
+
+    it 'returns subfield values from a given field' do
+      expect(util.subfield_values(field, :a)).to eq %w[A B C]
+    end
+  end
+
+  describe '.subfield_values_for' do
+    let(:record) do
+      marc_record fields: [marc_field(tag: '123', subfields: { a: %w[A B C], b: 'Not Included' }),
+                           marc_field(tag: '123', subfields: { a: 'D' }),
+                           marc_field(tag: '333', subfields: { a: 'Maybe', b: 'Nope' })]
+    end
+
+    it 'returns subfield values from only the specified tag and subfield' do
+      expect(util.subfield_values_for(tag: '123', subfield: :a, record: record)).to eq %w[A B C D]
+    end
+
+    it 'returns subfield values from only the specified tags and subfield' do
+      expect(util.subfield_values_for(tag: %w[123 333], subfield: :a, record: record)).to eq %w[A B C D Maybe]
+    end
+  end
+
+  describe '.trim_trailing' do
+    it 'trims the specified trailer from the string' do
+      expect(util.trim_trailing(:semicolon, 'Hello, world!  ;')).to eq('Hello, world!')
+    end
+  end
+
+  describe '.linked_alternate' do
+    let(:record) do
+      marc_record fields: [marc_field(tag: '254', subfields: { a: 'The Bible', b: 'Test' }),
+                           marc_field(tag: '880', subfields: { '6': '254', a: 'La Biblia', b: 'Prueba' })]
+    end
+
+    it 'returns the linked alternate' do
+      expect(util.linked_alternate(record, '254', &util.subfield_in?(%w[a b]))).to contain_exactly('La Biblia Prueba')
+    end
+  end
+
+  describe '.linked_alternate_not_6_or_8' do
+    let(:record) do
+      marc_record fields: [marc_field(tag: '510', subfields: { a: 'Perkins', b: 'Test' }),
+                           marc_field(tag: '880', subfields: { '6': '510', '8': 'Ignore', a: 'Snikrep', b: 'Tset' })]
+    end
+
+    it 'returns the linked alternate without 6 or 8' do
+      expect(util.linked_alternate_not_6_or_8(record, '510')).to contain_exactly('Snikrep Tset')
+    end
+  end
+
+  describe '.datafield_and_linked_alternate' do
+    let(:record) do
+      marc_record fields: [marc_field(tag: '510', subfields: { a: 'Perkins' }),
+                           marc_field(tag: '880', subfields: { '6': '510', a: 'Snikrep' })]
+    end
+
+    it 'returns the datafield and linked alternate' do
+      expect(util.datafield_and_linked_alternate(record, '510')).to contain_exactly('Perkins', 'Snikrep')
+    end
+  end
+
+  describe '.substring_before' do
+    it 'returns the entire substring after the first occurrence of the target' do
+      string = 'string.with.periods'
+      expect(util.substring_before(string, '.')).to eq 'string'
+    end
+  end
+
+  describe '.substring_after' do
+    it 'returns the entire substring after the first occurrence of the target' do
+      string = 'string.with.periods'
+      expect(util.substring_after(string, '.')).to eq 'with.periods'
+    end
+  end
+
+  describe '.join_and_squish' do
+    it 'joins and squishes' do
+      expect(util.join_and_squish(['ruby   ', '   is', '  cool  '])).to eq 'ruby is cool'
+    end
+  end
+
+  describe '.remove_paren_value_from_subfield_i' do
+    let(:field) { marc_field(tag: '666', subfields: { i: 'Test(Remove).' }) }
+    it 'removes the parentheses value from subfield i' do
+      expect(util.remove_paren_value_from_subfield_i(field)).to eq('Test')
+    end
+  end
+
+  describe '.translate_relator' do
+    let(:mapping) { { aut: 'Author' } }
+
+    it 'translates the code into the relator' do
+      expect(util.translate_relator(:aut, mapping)).to eq('Author')
+    end
+  end
+
+  describe '.prefixed_subject_and_alternate' do
+    let(:record) do
+      marc_record fields: [
+        marc_field(tag: '650', indicator2: '4', subfields: { a: 'PRO Heading' }),
+        marc_field(tag: '650', indicator2: '4', subfields: { a: 'Regular Local Heading' }),
+        marc_field(tag: '650', indicator2: '1', subfields: { a: 'LoC Heading' }),
+        marc_field(tag: '880', indicator2: '4', subfields: { '6': '650', a: 'PRO Alt. Heading' }),
+        marc_field(tag: '880', indicator2: '4', subfields: { '6': '999', a: 'Another Alt.' })
+      ]
+    end
+
+    it 'only includes valid headings' do
+      values = util.prefixed_subject_and_alternate(record, 'PRO')
+      expect(values).to include 'Heading', 'Alt. Heading'
+      expect(values).not_to include 'Regular Local Heading', 'LoC Heading', 'Another Alt.'
+    end
+  end
+end

data/spec/lib/pennmarc/parser_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+describe PennMARC::Parser do
+  include MarcSpecHelpers
+
+  let(:record) { record_from 'test.xml' }
+
+  subject(:parser) { described_class.new }
+
+  it 'delegates to helper modules properly' do
+    expect { parser.title_show(record) }.not_to raise_exception
+  end
+end