berkeley_library-tind 0.5.1 → 0.6.0

data/spec/berkeley_library/tind/mapping/alma_multiple_tind_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe AlmaMultipleTIND do
+        let(:additona_245_field) { [Util.datafield('245', [' ', ' '], [Util.subfield('a', 'fake 245 a')])] }
+        let(:marc_obj) { (::MARC::Record.new).append(additona_245_field) }
+
+        it ' get tind record' do
+          allow_any_instance_of(BerkeleyLibrary::TIND::Mapping::AlmaMultipleTIND).to receive(:alma_record_from).with('991085821143406532').and_return(marc_obj)
+          alma_multiple_tind = BerkeleyLibrary::TIND::Mapping::AlmaMultipleTIND.new('991085821143406532')
+
+          allow(alma_multiple_tind).to receive(:base_tind_record).with('991085821143406532', additona_245_field, marc_obj).and_return(marc_obj)
+          expect(alma_multiple_tind.record(additona_245_field)).to be marc_obj
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/mapping/alma_single_tind_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe AlmaSingleTIND do
+        let(:additona_245_field) { [Util.datafield('245', [' ', ' '], [Util.subfield('a', 'fake 245 a')])] }
+        let(:marc_obj) { (::MARC::Record.new).append(additona_245_field) }
+
+        before { BerkeleyLibrary::Alma::Config.default! }
+        after { BerkeleyLibrary::Alma::Config.send(:clear!) }
+
+        it ' get tind record' do
+          alma_single_tind = BerkeleyLibrary::TIND::Mapping::AlmaSingleTIND.new
+
+          allow(alma_single_tind).to receive(:base_tind_record).with('991085821143406532', additona_245_field).and_return(marc_obj)
+          expect(alma_single_tind.record('991085821143406532', additona_245_field)).to be marc_obj
+        end
+
+        describe 'TIND record mapping' do
+          let(:coll_param_hash) do
+            {
+              '336' => ['Image'],
+              '852' => ['East Asian Library'],
+              '980' => ['pre_1912'],
+              '982' => ['Pre 1912 Chinese Materials - short name', 'Pre 1912 Chinese Materials - long name'],
+              '991' => []
+            }
+          end
+
+          let(:id) { '991032333019706532' }
+          let(:marc_url) { BerkeleyLibrary::Alma::RecordId.parse(id).marc_uri.to_s }
+          let(:logger) { BerkeleyLibrary::Logging.logger }
+
+          before do
+            AlmaBase.collection_parameter_hash = coll_param_hash
+            AlmaBase.is_035_from_mms_id = true
+          end
+
+          after do
+            AlmaBase.collection_parameter_hash = nil
+            AlmaBase.is_035_from_mms_id = false
+          end
+
+          it 'transforms a record' do
+            marc_xml = File.read('spec/data/mapping/991032333019706532-sru.xml')
+            stub_request(:get, marc_url).to_return(body: marc_xml)
+
+            expect(logger).not_to receive(:warn)
+
+            mapper = BerkeleyLibrary::TIND::Mapping::AlmaSingleTIND.new
+            url = "https://digitalassets.lib.berkeley.edu/pre1912ChineseMaterials/ucb/ready/#{id}/#{id}_v001_0064.jpg"
+            fft = BerkeleyLibrary::TIND::Mapping::TindField.f_fft(url, 'v001_0064')
+            tind_record = mapper.record(id, [fft])
+
+            expect(tind_record).to be_a(::MARC::Record)
+            expect(tind_record['FFT']).to eq(fft)
+
+            expect(tind_record['901']['m']).to eq(id)
+            expect(tind_record['035']['a']).to eq("(pre_1912)#{id}")
+
+            alma_record = ::MARC::XMLReader.read(StringIO.new(marc_xml)).first
+            sf_245a_expected = alma_record.spec('245$a{$6=\880-02}').first
+            sf_245_value_expected = sf_245a_expected.value.sub(/[^[:alnum:]]+$/, '')
+
+            sf_245a_actual = tind_record.spec('245$a{$6=\880-02}').first
+            sf_245a_value_actual = sf_245a_actual.value
+            expect(sf_245a_value_actual).to eq(sf_245_value_expected)
+          end
+
+          it 'handles pathological records without an 001 control field' do
+            marc_xml = File.read('spec/data/mapping/991032333019706532-sru.xml')
+              .sub('<controlfield tag="001">991032333019706532</controlfield>', '')
+            stub_request(:get, marc_url).to_return(body: marc_xml)
+
+            expect(logger).to receive(:warn).with("#{id} has no Control Field 001")
+
+            mapper = BerkeleyLibrary::TIND::Mapping::AlmaSingleTIND.new
+            url = "https://digitalassets.lib.berkeley.edu/pre1912ChineseMaterials/ucb/ready/#{id}/#{id}_v001_0064.jpg"
+            fft = BerkeleyLibrary::TIND::Mapping::TindField.f_fft(url, 'v001_0064')
+            expect { mapper.record(id, [fft]) }.to raise_error(ArgumentError)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/mapping/alma_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe Alma do
+        let(:alma_obj) { Alma.new('spec/data/mapping/record.xml') }
+
+        it 'control field value' do
+          expect(alma_obj.control_field.tag).to eq '008'
+        end
+
+        it 'control field value' do
+          expect(alma_obj.control_field.tag).to eq '008'
+        end
+
+        it '880 field' do
+          expect(alma_obj.field_880('245-01/$1')['6']).to eq '245-01/$1'
+        end
+
+        it 'regular field' do
+          expect(alma_obj.field('245').tag).to eq '245'
+        end
+
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/mapping/config_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe Config do
+
+        it 'get the one to one mapping file' do
+          expect(Config.one_to_one_map_file).to end_with('one_to_one_mapping.csv')
+        end
+
+        it 'get the one to multiple mapping file' do
+          expect(Config.one_to_multiple_map_file).to end_with('one_to_multiple_mapping.csv')
+        end
+
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/mapping/csv_mapper_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe CsvMapper do
+        let(:dummy_class) { Class.new { extend CsvMapper } }
+        let(:from_tag) { %w[100 110 111 242 245 246 250 255 260 264 300 351 490 500 502 505 507 520 522 524 536 541 545 546 600 610 611 630 650 651 655 700 710 711 720 752 773 907] }
+        let(:rules_keys) { %i[tag_100 tag_110 tag_111 tag_242 tag_245 tag_246 tag_250 tag_255 tag_260 tag_264 tag_300 tag_351 tag_490 tag_500 tag_502 tag_505 tag_507 tag_520 tag_522 tag_524 tag_536 tag_541 tag_545 tag_546 tag_600 tag_610 tag_611 tag_630 tag_650 tag_651 tag_655 tag_700 tag_710 tag_711 tag_720 tag_752 tag_773 tag_907] }
+
+        it 'get origin tags' do
+          expect(dummy_class.from_tags).to eq from_tag
+        end
+
+        it 'get keys of rules' do
+          expect(dummy_class.rules.keys).to eq rules_keys
+        end
+
+        it 'get tag required one occurrence in csv ' do
+          expect(dummy_class.one_occurrence_tags).to eq ['264']
+        end
+
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/mapping/csv_multiple_mapper_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe CsvMultipleMapper do
+        let(:dummy_class) { Class.new { extend CsvMultipleMapper } }
+        let(:from_tag) { ['008', 'LDR'] }
+        let(:rules_keys) { %i[tag_008 tag_LDR] }
+
+        it 'get origin tags' do
+          expect(dummy_class.from_tags).to eq from_tag
+        end
+
+        it 'get keys of rules' do
+          expect(dummy_class.rules.keys).to eq rules_keys
+        end
+
+        it 'get 2 rules on tag "008" ' do
+          expect(dummy_class.send(:rules_on_tag, '008').count).to eq 2
+        end
+
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/mapping/external_tind_field_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe ExternalTindField do
+        describe '# tind_fields_from_collection_information' do
+          let(:good_hash) do
+            {   '336' => ['Image'],
+                '852' => ['East Asian Library'],
+                '980' => ['pre_1912'],
+                '982' => ['Pre 1912 Chinese Materials', 'Pre 1912 Chinese Materials'],
+                '991' => [] }
+          end
+          let(:bad_hash) { {} }
+          let(:output_collection_tags) { %w[336 852 980 982] }
+
+          it 'get tind datafields derived from collection information' do
+            expect(ExternalTindField.tind_fields_from_collection_information(good_hash).map(&:tag)).to eq output_collection_tags
+          end
+
+          it 'get [] derived from empty collection information' do
+            expect { ExternalTindField.tind_fields_from_collection_information(bad_hash).map(&:tag) }.to raise_error(ArgumentError)
+          end
+        end
+
+        describe '# tind_fields_from_alma_id' do
+          let(:output_alma_tags) { %w[901 856] }
+
+          it 'get derived tind fields from alma id' do
+            alma_id = '991085821143406532'
+            expect(ExternalTindField.tind_mms_id_fields(alma_id).map(&:tag)).to eq output_alma_tags
+          end
+
+          it 'get empty tind fields from a nil alma id' do
+            alma_id = nil
+            expect { ExternalTindField.tind_mms_id_fields(alma_id).map(&:tag) }.to raise_error(ArgumentError)
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/mapping/field_catalog_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      # 14 tags match origin tags defined in csv file
+      # ["245", "246", "260", "300", "300", "490", "630", "650", "650", "700", "710", '264', '264','507']
+      describe DataFieldsCatalog do
+
+        let(:qualified_alma_obj) { Alma.new('spec/data/mapping/record.xml') }
+        let(:qualified_alm_record) { qualified_alma_obj.record }
+        let(:datafields_catalog) { DataFieldsCatalog.new(qualified_alm_record) }
+        let(:mms_id) { '991046494559706532' }
+
+        let(:alma_tags) { %w[255 245 246 260 300 300 490 630 650 700 710] }
+        let(:alma_tags_with_pre_existed_tag) { ['264'] }
+        let(:alma_tags_with_pre_existed_tag_subfield) { ['507'] }
+
+        let(:f880_subfield6) { %w[880-245-01 880-246-02 880-260-03 880-490-04 880-650-05 880-700-06 880-710-07] }
+        let(:f880_subfield6_with_pre_existed_tag) { [] }
+        let(:f880_subfield6_with_pre_existed_tag_subfield) { ['880-507-09'] }
+
+        # 880 datafield with "880-510-00" should not be includede
+        let(:f880_sbufield6_with_00) { %w[880-500-00 880-500-00 880-500-00 880-500-00] }
+        let(:not_f880_sbufield6_with_00) { '880-510-00' }
+
+        it 'get control_fields' do
+          expect(datafields_catalog.control_fields.count).to eq 3
+        end
+
+        it 'get mms_id' do
+          expect(datafields_catalog.mms_id).to eq mms_id
+        end
+
+        context '# From regular fields' do
+
+          # One-occurence mapping: there are two 264 datafields in record, only the first one is added
+          it 'get regular datafield tags' do
+            expect(datafields_catalog.data_fields_group[:normal].map(&:tag)).to eq alma_tags
+          end
+
+          it 'get datafield tags with pre_existed datafield defined in csv' do
+            expect(datafields_catalog.data_fields_group[:pre_tag].map(&:tag)).to eq alma_tags_with_pre_existed_tag
+          end
+
+          it 'get datafield tags with pre_existed datafield and subfield defined in csv' do
+            expect(datafields_catalog.data_fields_group[:pre_tag_subfield].map(&:tag)).to eq alma_tags_with_pre_existed_tag_subfield
+          end
+
+        end
+
+        context '# From 880 fields' do
+          it 'get 880 datafields -  subfield 6 number is 00 ' do
+            expect(datafields_catalog.fields_880_subfield6(datafields_catalog.data_fields_880_00)).to eq f880_sbufield6_with_00
+          end
+
+          it 'get 880 datafields -  subfield 6 number is not 00 ' do
+            expect(datafields_catalog.fields_880_subfield6(datafields_catalog.data_fields_880_00)).not_to include not_f880_sbufield6_with_00
+          end
+
+          it 'get regular subfield 6' do
+            expect(datafields_catalog.fields_880_subfield6(datafields_catalog.data_fields_880_group[:normal])).to eq f880_subfield6
+          end
+
+          it 'get regular subfield 6: pre_exsisted datafield' do
+            expect(datafields_catalog.data_fields_880_group[:pre_tag]).to eq f880_subfield6_with_pre_existed_tag
+          end
+
+          it 'get regular subfield 6: pre_exsisted datafield and subfield from' do
+            expect(datafields_catalog.fields_880_subfield6(datafields_catalog.data_fields_880_group[:pre_tag_subfield])).to eq f880_subfield6_with_pre_existed_tag_subfield
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/mapping/field_catalog_util_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe FieldCatalogUtil do
+        include Util
+        include Misc
+        include FieldCatalogUtil
+        include TindSubfieldUtil
+        include CsvMapper
+
+        let(:qualified_alma_obj) { Alma.new('spec/data/mapping/record.xml') }
+        let(:qualified_alm_record) { qualified_alma_obj.record }
+        let(:regular_field_tags) do
+          %w[255
+             507
+             245
+             246
+             260
+             300
+             490
+             630
+             650
+             700
+             710
+             264]
+        end
+
+        let(:normal) { %w[255 245 246 260 300 300 490 630 650 650 700 710] }
+        let(:pre_tag) { ['264', '264'] }
+        let(:pre_tag_subfield) { ['507'] }
+
+        it 'excluding fast subject field' do
+          fields = qualified_alm_record.fields.select { |f| ['650', '245'].include? f.tag }
+          expect(fields.length).to eq 3
+
+          final_fields = exluding_fields_with_fast_subject(fields)
+          expect(final_fields.length).to eq 2
+          expect(final_fields[0].tag).to eq '245'
+
+        end
+
+        it 'preparing field group' do
+          fields = qualified_alm_record.fields.select { |f| regular_field_tags.include? f.tag }
+          expect(fields.length).to eq 15
+
+          group = prepare_group(fields)
+          expect(group[:normal].map(&:tag)).to eq normal
+          expect(group[:pre_tag].map(&:tag)).to eq pre_tag
+          expect(group[:pre_tag_subfield].map(&:tag)).to eq pre_tag_subfield
+        end
+
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/mapping/match_tind_field_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe MatchTindField do
+
+        let(:qualified_alma_obj) { Alma.new('spec/data/mapping/record.xml') }
+        let(:qualified_alm_record) { qualified_alma_obj.record }
+
+        let(:tind_marc) { TindMarc.new(qualified_alm_record) }
+
+        let(:data_fields) { tind_marc.field_catalog.data_fields_880_group[:normal].concat tind_marc.field_catalog.data_fields_group[:normal] }
+        let(:no_880_matching_count) { 4 }
+
+        it 'get 880 un-matched fields' do
+          # puts tind_marc.send(:un_matched_fields_880, data_fields, '991032577079706532').inspect
+          expect(tind_marc.send(:un_matched_fields_880, data_fields, '991032577079706532').length).to eq no_880_matching_count
+        end
+
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/mapping/misc_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe Misc do
+        let(:qualified_alma_obj) { Alma.new('spec/data/mapping/record.xml') }
+        let(:qualified_alm_record) { qualified_alma_obj.record }
+
+        let(:tind_marc) { TindMarc.new(qualified_alm_record) }
+        let(:regular_field_with_subfield6) { qualified_alma_obj.field('246') }
+        let(:field_880_with_subfield6) { qualified_alma_obj.field_880('490-04/$1') }
+        let(:field_880_without_subfield6) { qualified_alma_obj.field_880(nil) }
+
+        it 'get field tag' do
+          expect(tind_marc.origin_mapping_tag(regular_field_with_subfield6)).to eq '246'
+        end
+
+        it 'get tag from subfield 6' do
+          expect(tind_marc.origin_mapping_tag(field_880_with_subfield6)).to eq '490'
+        end
+
+        it 'get nil when no fubfiel6' do
+          expect(tind_marc.referred_tag(field_880_without_subfield6)).to eq nil
+        end
+
+        it '880 field has a refered tag' do
+          expect(tind_marc.field_880_has_referred_tag?('490', field_880_with_subfield6)).to eq true
+        end
+
+        it '880 field has no refered tag' do
+          expect(tind_marc.field_880_has_referred_tag?('490', field_880_without_subfield6)).to eq false
+        end
+
+        it 'remove defined punctuations' do
+          expect(tind_marc.send(:clr_value, ' [1785] Qing Qianlong 50 nian :,')).to eq '1785  Qing Qianlong 50 nian'
+        end
+
+        it 'get seq number' do
+          expect(tind_marc.send(:seq_no, '245-01/$1')).to eq 1
+        end
+
+        it 'get seq number - 0' do
+          expect(tind_marc.send(:seq_no, '550')).to eq 0
+        end
+
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/mapping/multiple_rule_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'csv'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+
+      describe MultipleRule do
+
+        attr_reader :multiple_rule
+
+        before(:each) do
+          rows = Util.csv_rows('spec/data/mapping/one_to_multiple_mapping.csv')
+          @multiple_rule = MultipleRule.new(rows[0])
+        end
+
+        it 'get origin tag' do
+          expect(multiple_rule.tag_origin).to eq '008'
+        end
+
+        it 'get destination tag' do
+          expect(multiple_rule.tag_destination).to eq '041'
+        end
+
+        it 'get indicator' do
+          expect(multiple_rule.indicator).to eq [' ', ' ']
+        end
+
+        it 'get pre_existed tag' do
+          expect(multiple_rule.pre_existed_tag).to eq '041'
+        end
+
+        it 'get subfield key' do
+          expect(multiple_rule.subfield_key).to eq 'a'
+        end
+
+        it 'get position from and to' do
+          expect(multiple_rule.position_from_to).to eq [35, 37]
+        end
+
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/mapping/single_rule_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'csv'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+
+      describe SingleRule do
+
+        attr_reader :single_rule
+
+        before(:each) do
+          rows = Util.csv_rows('spec/data/mapping/one_to_one_mapping.csv')
+          @single_rule = SingleRule.new(rows[4])
+        end
+
+        it 'get origin tag' do
+          expect(single_rule.tag_origin).to eq '245'
+        end
+
+        it 'get destination tag' do
+          expect(single_rule.tag_destination).to eq '245'
+        end
+
+        it 'get indicator' do
+          expect(single_rule.indicator).to eq [' ', ' ']
+        end
+
+        it 'get combined rules' do
+          expect(single_rule.combined_rules).to eq [[['n,p', 'p', nil]], [['b,f,k', 'b', nil]]] # combination rules mapped to p and b
+        end
+
+        it 'get pre_existed_tag' do
+          expect(single_rule.pre_existed_tag).to eq nil
+        end
+
+        it 'get pre_existed_tag_subfield ' do
+          expect(single_rule.pre_existed_tag_subfield).to eq nil
+        end
+
+        it 'get single rule exluding pre_existed_subfield hash' do
+          expect(single_rule.single_rule_subfield_excluded_hash).to eq({ '6' => '6', 'a' => 'a' })
+        end
+
+        it 'get single rule' do
+          expect(single_rule.single_rule_hash).to eq({ '6' => '6', 'a' => 'a' })
+        end
+
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/mapping/tind_control_subfield_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe TindControlSubfield do
+        let(:dummy_obj) { Class.new { extend TindControlSubfield } }
+        let(:dumy_obj_multiple_mapper) { Class.new { extend CsvMultipleMapper } }
+        let(:leader_rules) { dumy_obj_multiple_mapper.rules[:tag_008] }
+        let(:rule) { leader_rules[1] }
+        # When 001 value is copied from xml file, it missed 13 spaces, added manually
+        let(:leader_val_normal)   { '970502i19101920vp nnn              kneng d' }
+        let(:leader_val_uu)       { '970423q19uu19uuxxunnn              kneng d' }
+        let(:leader_val_u)        { '970501q195u195ule nnn              kneng d' }
+        let(:leader_val_not_good) { '970501i caunnn                     kneng d' }
+
+        context '#Normal year - 269 field' do
+          let(:sub_val) { dummy_obj.extract_value(rule, leader_val_normal) }
+
+          it '#extract_value year in dddd' do
+            expect(sub_val).to eq '1910'
+          end
+
+          it '#extracted_field - 269__$a: dddd' do
+            field = dummy_obj.extracted_field(rule, sub_val)
+            expect(field.tag).to eq '269'
+            expect(field['a']).to eq '1910'
+          end
+
+          it '#extracted_fields_from_leader: get two fields' do
+            fields = dummy_obj.extracted_fields_from_leader(leader_rules, leader_val_normal)
+            expect(fields.map(&:tag)).to eq ['041', '269']
+          end
+        end
+
+        context '#Year with "uu" - 269 field' do
+          let(:sub_val) { dummy_obj.extract_value(rule, leader_val_uu) }
+
+          it '#extract_value year in dduu' do
+            expect(sub_val).to eq '19uu'
+          end
+
+          it '#extracted_field - 269 = nil' do
+            field = dummy_obj.extracted_field(rule, sub_val)
+            expect(field).to eq nil
+          end
+
+          it '#extracted_fields_from_leader: get one field ' do
+            fields = dummy_obj.extracted_fields_from_leader(leader_rules, leader_val_uu)
+            expect(fields.map(&:tag)).to eq ['041']
+          end
+
+        end
+
+        context '#Year with "u" - 269 field' do
+          let(:sub_val) { dummy_obj.extract_value(rule, leader_val_u) }
+
+          it '#extract_value year in dddu' do
+            expect(sub_val).to eq '195u'
+          end
+
+          it '#extracted_field - 269__$a: ddd0' do
+            field = dummy_obj.extracted_field(rule, sub_val)
+            expect(field.tag).to eq '269'
+            expect(field['a']).to eq '1950'
+          end
+
+          it '#extracted_fields_from_leader: get two fields ' do
+            fields = dummy_obj.extracted_fields_from_leader(leader_rules, leader_val_u)
+            expect(fields.map(&:tag)).to eq ['041', '269']
+          end
+
+        end
+
+        context '#None year - 269 field' do
+          let(:sub_val) { dummy_obj.extract_value(rule, leader_val_not_good) }
+
+          it '#extract_value year - not integer string' do
+            expect(sub_val).to eq ' cau'
+          end
+
+          it '#extracted_field - 269 = nil' do
+            field = dummy_obj.extracted_field(rule, sub_val)
+            expect(field).to eq nil
+          end
+
+          it '#extracted_fields_from_leader: get one field ' do
+            fields = dummy_obj.extracted_fields_from_leader(leader_rules, leader_val_uu)
+            expect(fields.map(&:tag)).to eq ['041']
+          end
+
+        end
+      end
+    end
+  end
+end