berkeley_library-tind 0.5.1 → 0.7.0

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,105 @@
+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'] }
+
+        after do
+          BerkeleyLibrary::TIND::Mapping::AlmaBase.including_origin_tags = []
+          BerkeleyLibrary::TIND::Mapping::AlmaBase.excluding_origin_tags = []
+        end
+
+        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
+
+        context 'Defining list of fields mapping from Alma to TIND' do
+          it 'no including, excluding defined from config, return all Alma fields for mapping' do
+            selected_field_tags = %w[255 507 245 246 260 300]
+            fields = qualified_alm_record.fields.select { |f| selected_field_tags.include? f.tag }
+            expect(fields_to_map(fields).map(&:tag)).to eq %w[255 507 245 246 260 300 300]
+          end
+
+          it 'both including and excluding have tags, return empty: not allow to define both including and excluding at the same time' do
+            BerkeleyLibrary::TIND::Mapping::AlmaBase.including_origin_tags = %w[254 650]
+            BerkeleyLibrary::TIND::Mapping::AlmaBase.excluding_origin_tags = %w[507 255 650 880]
+
+            selected_field_tags = %w[255 507 245 246 260 300]
+            fields = qualified_alm_record.fields.select { |f| selected_field_tags.include? f.tag }
+            expect(fields_to_map(fields).map(&:tag)).to eq []
+          end
+
+          it 'only including is defined: keeping fields defined in BerkeleyLibrary::TIND::Mapping::AlmaBase.including_origin_tags' do
+            selected_field_tags = regular_field_tags
+            selected_field_tags << '880'
+            selected_field_tags << '001'
+            fields = qualified_alm_record.fields.select { |f| selected_field_tags.include? f.tag }
+            BerkeleyLibrary::TIND::Mapping::AlmaBase.including_origin_tags = %w[255 650]
+            expect(fields_to_map(fields).map(&:tag)).to eq %w[001 255 650 650 880]  # return: Two 650 fields, one 880 field with subfield6 = '650'
+          end
+
+          context 'only excluding origin tags are defined ' do
+            it 'excluding has 880, all 880 fields will be excluded.' do
+              selected_field_tags = %w[001 880 245 507 255 650 630 700 264]
+              fields = qualified_alm_record.fields.select { |f| selected_field_tags.include? f.tag }
+              BerkeleyLibrary::TIND::Mapping::AlmaBase.excluding_origin_tags = %w[507 255 650 880]
+              final_field_tags = %w[001 245 630 700 264 264] # no 880 fields kept
+              expect(fields_to_map(fields).map(&:tag)).to eq final_field_tags
+            end
+
+            it 'excluding has no 880, only 880 whose refered tag located in excluding list will be skipped ' do
+              selected_field_tags = %w[001 880 245 507 255 650 630 700 264]
+              fields = qualified_alm_record.fields.select { |f| selected_field_tags.include? f.tag }
+              BerkeleyLibrary::TIND::Mapping::AlmaBase.excluding_origin_tags = %w[507 255 650]
+              final_field_tags = %w[001 245 880 880 880 880 630 880 700 880 880 880 880 880 880 880 264 264]
+              expect(fields_to_map(fields).map(&:tag)).to eq final_field_tags
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+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) { 5 }
+
+        it 'get 880 un-matched fields' do
+          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

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe TindFieldFromLeader 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(:tindfield_from_leader) { TindFieldFromLeader.new(qualified_alm_record) }
+
+        it 'get_tindfields' do
+          expect(tindfield_from_leader.to_datafields[0].tag).to eq '903'
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      # using 008 field: csv file, one_to_multiple csv file should have 008 field
+      # tag_origin	tag_destination	map_if_no_this_tag_existed	subfield_key	new_indecator	value_from	value_to
+      # 008	      41             	41	                         a            _,_	          35	         37
+      # 008	      269	                                         a	          _,_         	7	           10
+
+      describe TindFieldFromMultipleMap do
+
+        let(:qualified_alma_obj) { Alma.new('spec/data/mapping/record.xml') }
+        let(:qualified_alm_record) { qualified_alma_obj.record }
+        let(:tindfield_from_multiple_map) { TindFieldFromMultipleMap.new(qualified_alma_obj.control_field, []) }
+
+        it 'get tindfields without pre_existing tindfields' do
+          expect(tindfield_from_multiple_map.to_datafields.count).to eq 2
+        end
+
+        it 'get tindfields with pre_existing tindfields' do
+          current_fields = [] << ::MARC::DataField.new('041', ' ', ' ', ::MARC::Subfield.new('a', 'chi'))
+          multiple_map = TindFieldFromMultipleMap.new(qualified_alma_obj.control_field, current_fields)
+          expect(multiple_map.to_datafields.count).to eq 1
+        end
+
+      end
+    end
+  end
+end