berkeley_library-tind 0.5.1 → 0.6.0

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

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

@@ -0,0 +1,150 @@
+require 'spec_helper'
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe TindFieldFromSingleMap do
+        let(:qualified_alma_obj) { Alma.new('spec/data/mapping/record.xml') }
+        let(:qualified_alm_record) { qualified_alma_obj.record }
+        let(:tindfield_from_single_map) { TindFieldFromSingleMap.new(qualified_alma_obj.field('245'), false) }
+
+        # 1. Subfield one to one mapping
+        # 2. Subfield not listed in csv file is not mapped
+        describe '1. subfield one to one mapping' do
+          it 'get tindfield tag: 245 => 245 ' do
+            expect(tindfield_from_single_map.to_datafield.tag).to eq '245'
+          end
+
+          it 'get 245$a' do
+            expect(tindfield_from_single_map.to_datafield['a']).to eq 'Cang jie pian :'
+          end
+
+          it 'get 245$b' do
+            expect(tindfield_from_single_map.to_datafield['b']).to eq '[san juan] /'
+          end
+
+          it 'get 245$6' do
+            expect(tindfield_from_single_map.to_datafield['6']).to eq '880-99'
+          end
+
+          it 'shoud not get 245$c' do
+            expect(tindfield_from_single_map.to_datafield['c']).to eq nil
+          end
+        end
+        describe '2. mapping indicators' do
+          let(:tindfield_from_single_map) { TindFieldFromSingleMap.new(qualified_alma_obj.field('710'), false) }
+
+          it 'get indicator1' do
+            expect(tindfield_from_single_map.to_datafield.indicator1).to eq '2'
+          end
+
+          it 'get indicator2' do
+            expect(tindfield_from_single_map.to_datafield.indicator2).to eq ' '
+          end
+
+        end
+
+        # 264 datafield mapping defined in csv has only one mapping occurrence
+        # To test only the first occurrence is mapped
+        describe '3. multiple origin 264 fields => only mapping the first occurrence' do
+          let(:tindfield_from_single_map) { TindFieldFromSingleMap.new(qualified_alma_obj.field('264'), false) }
+
+          it 'get tindfield tag: 264 => 260' do
+            expect(tindfield_from_single_map.to_datafield.tag).to eq '260'
+          end
+
+          it 'get the first 264$a' do
+            expect(tindfield_from_single_map.to_datafield['a']).to eq '264 fake a 1'
+          end
+
+          it 'get the first 264$b' do
+            expect(tindfield_from_single_map.to_datafield['b']).to eq '264 fake b 1'
+          end
+
+          it 'get the first 264$c' do
+            expect(tindfield_from_single_map.to_datafield['c']).to eq '264 fake c 1'
+          end
+        end
+
+        # 1. 507 datafield has pre-existed subfield a defined in csv file
+        # 2. To test excluding subfield a mapping from  507
+        # 3. TindFieldFromSingleMap.new(): input excluding_subfield = true
+        describe '4. pre_existed subfield = true' do
+          let(:tindfield_from_single_map) { TindFieldFromSingleMap.new(qualified_alma_obj.field('507'), true) }
+
+          it 'get tindfield tag: 507 => 255 ' do
+            expect(tindfield_from_single_map.to_datafield.tag).to eq '255'
+          end
+
+          it 'pre_existed 507$a is not mapped' do
+            expect(tindfield_from_single_map.to_datafield['a']).to eq nil
+          end
+        end
+
+        # To test rule: subfield value combined without concatenation symbol defined in csv
+        describe '5. subfields are combined' do
+          let(:tindfield_from_single_map) { TindFieldFromSingleMap.new(qualified_alma_obj.field('246'), false) }
+
+          it 'get tindfield tag: 246 => 246' do
+            expect(tindfield_from_single_map.to_datafield.tag).to eq '246'
+          end
+
+          it 'get combined subfield a, b, p, n' do
+            expect(tindfield_from_single_map.to_datafield['a']).to eq 'Sun shi Cang jie pian ^^ b fake ^^ p fake ^^ n fake'
+          end
+
+        end
+
+        # To test multiple rules mapped to the same tinddatafield
+        describe '6. subfields are combined with multiple rules' do
+          let(:tindfield_from_single_map) { TindFieldFromSingleMap.new(qualified_alma_obj.field('630'), false) }
+          let(:combined_value) { 'fake a *  fake b * fake c * fake d * fake f * fake j * fake k * fake l * fake m * fake n * fake o * fake p * fake q * fake r * fake s * fake t * fake x1  -- fake x2  ' }
+
+          it 'get tindfield tag: 630 => 630' do
+            expect(tindfield_from_single_map.to_datafield.tag).to eq '630'
+          end
+
+          it 'get combined subfield a, b, p, n' do
+            expect(tindfield_from_single_map.to_datafield['a']).to eq combined_value
+          end
+
+        end
+
+        # 1. To test 880 datafield
+        # 2. 880 tag reversed
+        # 3. subfields z,y, z combined with concatenation symbol defined in csv file
+        describe '7. 880 datafield mapping' do
+          let(:tindfield_from_single_map) { TindFieldFromSingleMap.new(qualified_alma_obj.field_880('650-05/$1'), false) }
+
+          it 'get tindfield tag: 880 => 880' do
+            expect(tindfield_from_single_map.to_datafield.tag).to eq '880'
+          end
+
+          it 'get 880$a: subfield a x,y,z combined to subfield a with symbol " -- " ' do
+            expect(tindfield_from_single_map.to_datafield['a']).to eq '經部 小學類 -- 字書. '
+          end
+
+        end
+
+        # 1. To test 880 datafield
+        # 2. Tag in 880 subfield 6 is mapped based on a regular datafield mapping rule
+        # 3. 880 datafield with 507 tag in subfield 6
+        #   mapped from 507-09/$1 to 255-09/$1
+        describe '8. 880 subfield 6 value mapped to new destination tag' do
+          let(:tindfield_from_single_map) { TindFieldFromSingleMap.new(qualified_alma_obj.field_880('507-09/$1'), false) }
+
+          it 'get tindfield tag: 880 => 880' do
+            expect(tindfield_from_single_map.to_datafield.tag).to eq '880'
+          end
+
+          it 'get subfield 6: "507-09/$1" => "255-09/$1" ' do
+            expect(tindfield_from_single_map.to_datafield['6']).to eq '255-09/$1'
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe TindField do
+        it 'Field 035' do
+          f = TindField.f_035('Alibaba123')
+          expect(f.tag).to eq '035'
+          expect(f['a']).to eq 'Alibaba123'
+        end
+
+        it 'Field 035 derived from mms_id' do
+          f = TindField.f_035_from_alma_id('991085821143406532', 'cu_news')
+          expect(f.tag).to eq '035'
+          expect(f['a']).to eq  '(cu_news)991085821143406532'
+        end
+
+        it 'Field 245$p' do
+          f = TindField.f_245_p('fake_title_version')
+          expect(f.tag).to eq '245'
+          expect(f['p']).to eq 'fake_title_version'
+        end
+
+        it 'Field FFT' do
+          f = TindField.f_fft('http://host/image.tif', 'news')
+          expect(f.tag).to eq 'FFT'
+          expect(f['a']).to eq  'http://host/image.tif'
+          expect(f['d']).to eq  'news'
+        end
+
+        it 'Field 902$d' do
+          f = TindField.f_902_d
+          puts f['d']
+          expect(f.tag).to eq '902'
+          expect(f['d']).to match(/^\d{4}-\d{2}-\d{2}$/)
+        end
+
+        it 'Field 902$n' do
+          f = TindField.f_902_n('YZ')
+          expect(f.tag).to eq '902'
+          expect(f['n']).to eq  'YZ'
+        end
+
+        it 'Field 982$p' do
+          f = TindField.f_982_p('project name')
+          expect(f.tag).to eq '982'
+          expect(f['p']).to eq 'project name'
+        end
+
+        it 'Marc field' do
+          f = TindField.f('998', 'g', 'file name')
+          expect(f.tag).to eq '998'
+          expect(f['g']).to eq 'file name'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe TindFieldUtil 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(:normal_fields_group) { tind_marc.field_catalog.data_fields_group[:normal] }
+        let(:field_normal) { qualified_alma_obj.field('245') }
+        let(:field_pre_existed_field) { qualified_alma_obj.field('264') } # 264 has pre_existed field defined in csv file
+        let(:field_pre_existed_field_and_subfield) { qualified_alma_obj.field('507') } # 507 has pre_existed_field_subfield defined in csv file
+        let(:fields_880_group) { tind_marc.field_catalog.data_fields_880_group[:normal] }
+        let(:field_880_245) { qualified_alma_obj.field_880('245-01/$1') }
+
+        it 'get a rule on datafield' do
+          expect(tind_marc.rule(field_normal)).to be_an_instance_of BerkeleyLibrary::TIND::Mapping::SingleRule
+        end
+
+        it 'tindfield found existing list of tindfields' do
+          expect(tind_marc.tindfield_existed?(field_pre_existed_field, normal_fields_group)).to eq true
+        end
+
+        it 'tindfield not found existing list of tindfields' do
+          expect(tind_marc.tindfield_existed?(field_normal, normal_fields_group)).to eq false
+        end
+
+        # fake 255$a existing in the record.xml
+        it 'tindfield subfield found in existing list of tindfields' do
+          expect(tind_marc.tindfield_subfield_existed?(field_pre_existed_field_and_subfield, normal_fields_group)).to eq true
+        end
+
+        it 'tindfield subfield not found existing list of tindfields' do
+          expect(tind_marc.tindfield_subfield_existed?(field_normal, normal_fields_group)).to eq false
+        end
+
+        it 'find an 880 field, subfield6 including tag 245' do
+          expect(tind_marc.field_880_on_subfield6_tag('245', fields_880_group)['6']).to eq '245-01/$1'
+        end
+
+        describe '# field_pre_existed' do
+          it 'find pre_existed 880 field' do
+            expect(tind_marc.send(:field_pre_existed, '245', field_880_245, fields_880_group)['6']).to eq '245-01/$1'
+          end
+
+          it 'find no pre_existed 880 field' do
+            expect(tind_marc.send(:field_pre_existed, '247', field_880_245, fields_880_group)).to eq nil
+          end
+
+          it 'find pre_existed regular field' do
+            expect(tind_marc.send(:field_pre_existed, '245', field_normal, normal_fields_group).tag).to eq '245'
+          end
+
+          it 'find no pre_existed regular field' do
+            expect(tind_marc.send(:field_pre_existed, '299', field_normal, normal_fields_group)).to eq nil
+          end
+
+        end
+
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe TindMarc 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(:normal_fields) { [qualified_alma_obj.field('245'), qualified_alma_obj.field('507')] }
+        let(:normal_tindfield_tags) { ['245', '255'] }
+
+        let(:with_pre_existed_fields) { [qualified_alma_obj.field('245'), qualified_alma_obj.field('264')] }
+        let(:current_fields) { [qualified_alma_obj.field('245'), qualified_alma_obj.field('260')] }
+        let(:with_pre_existed_tind_fields_tags) { ['245'] }
+
+        let(:with_pre_existed_subfield_fields) { [qualified_alma_obj.field('245'), qualified_alma_obj.field('507')] }
+        let(:current_with_pre_existed_subfield_fields) { [qualified_alma_obj.field('245'), qualified_alma_obj.field('255')] }
+        let(:with_pre_existed_tind_subfield_fields_tags) { ['245'] }
+
+        # mapped on pre_existed_field rule: "260"
+        # mapped on pre_existed_subfield rule:  "255"
+        let(:tindfield_tags) do
+          %w[255 245 246 260 300 300 490 630 650
+             700 710 903 041 269 255]
+        end
+
+        let(:tind_880_subfield6_tags) { ['245', '246', '260', '490', '650', '700', '710', '255', nil, '500', '500', '500', '500'] }
+
+        # mapped on pre_existed_field rule  => ''
+        # mapped on pre_existed_subfield rule:  "880-255-09"
+        # 880 datafields with '00' in subfield 6 come from field_catalog - 4 tindfields
+        let(:tindfield_880_normal_tags) do
+          %w[880-245-01 880-246-02 880-260-03 880-490-04 880-650-05
+             880-700-06 880-710-07 880-255-09
+             880-500-00 880-500-00 880-500-00 880-500-00]
+        end
+
+        context '# From public methods: ' do
+          it 'get a TIND record' do
+            expect(tind_marc.tind_record).to be_a ::MARC::Record
+          end
+
+          it 'get all tindfields' do
+            expect(tind_marc.tindfields.count).to eq 28 # 7 (normal tindfields) + 21 (880 tindfields)
+          end
+        end
+
+        context '# From private methods: ' do
+
+          it 'get normal tindfield tags' do
+            expect(tind_marc.send(:tindfields_group).map(&:tag)).to eq tindfield_tags
+          end
+
+          it 'get 880 tindfield tags' do
+            expect(tind_marc.send(:tindfields_group_880).map { |f| tind_marc.origin_mapping_tag(f) }).to eq tind_880_subfield6_tags
+          end
+
+          it 'get 880 tindfield subfield6 values' do
+            expect(tind_marc.fields_880_subfield6(tind_marc.send(:tindfields_group_880))).to eq tindfield_880_normal_tags
+          end
+
+          it 'get normal tindfields' do
+            expect(tind_marc.send(:tindfields_from_normal, normal_fields).map(&:tag)).to eq normal_tindfield_tags
+          end
+
+          it 'get control tindfields' do
+            expect(tind_marc.send(:tindfields_from_control, []).map(&:tag)).to eq ['041', '269']
+          end
+
+          it 'get tindfields with pre_existed field' do
+            expect(tind_marc.send(:tindfields_with_pre_existed_field, with_pre_existed_fields, current_fields).map(&:tag)).to eq with_pre_existed_tind_fields_tags
+          end
+
+          it 'get tindfields with pre_existed_subfield' do
+            expect(tind_marc.send(:tindfields_with_pre_existed_subfield, with_pre_existed_subfield_fields, current_with_pre_existed_subfield_fields).map(&:tag)).to eq normal_tindfield_tags
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe TindSubfieldUtil 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(:regular_field_with_subfield6) { qualified_alma_obj.field('246') }
+        let(:regular_field_without_subfield6) { qualified_alma_obj.field('300') }
+        let(:field_880_with_subfield6) { qualified_alma_obj.field_880('490-04/$1') }
+        let(:field_880_without_subfield6) { qualified_alma_obj.field_880(nil) }
+        let(:no_880_matching_list) { ['No matching: 880 $ 245-01/$1 ', 'No matching: 245 $ 880-99 ', 'No matching: 630 $ 880-16 '] }
+        let(:subfield6_values) { ['245-01/$1', '880-16', '246-02/$04', '880-02'] }
+
+        it 'get origin tag from regular field' do
+          expect(tind_marc.origin_mapping_tag(regular_field_with_subfield6)).to eq '246'
+        end
+
+        it 'get clean value' do
+          str = 'to [test] removing : special characters :;/'
+          expect(tind_marc.send(:clr_value, str)).to eq 'to  test  removing : special characters'
+        end
+
+        it 'get the lowest seq no' do
+          expect(tind_marc.send(:subfield6_value_with_lowest_seq_no, subfield6_values)).to eq '245-01/$1'
+        end
+
+        context 'get origin tag from a 880 field' do
+          it 'with subfield6' do
+            expect(tind_marc.origin_mapping_tag(field_880_with_subfield6)).to eq '490'
+          end
+
+          it 'without subfield6' do
+            expect(tind_marc.origin_mapping_tag(field_880_without_subfield6)).to eq nil
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe Util do
+
+        let(:qualified_alma_obj) { Alma.new('spec/data/mapping/record.xml') }
+        let(:qualified_alm_record) { qualified_alma_obj.record }
+
+        let(:un_qualified_alma_obj) { Alma.new('spec/data/mapping/record_not_qualified.xml') }
+        let(:un_qualified_alm_record) { un_qualified_alma_obj.record }
+
+        let(:field) { qualified_alma_obj.field('260') }
+        let(:subfield_hash) do
+          { '6' => '880-03',
+            'a' => '[Daliang] :',
+            'b' => 'Daliang fu shu,',
+            'c' => 'Qing Qianlong 50 nian [1785]' }
+        end
+
+        it 'get three digits' do
+          tag = '1'
+          expect(Util.send(:format_tag, tag)).to eq '001'
+        end
+
+        it 'get letters' do
+          tag = 'LDR'
+          expect(Util.send(:format_tag, tag)).to eq 'LDR'
+        end
+
+        it 'get subfield hash from a field' do
+          expect(Util.subfield_hash(field)).to eq subfield_hash
+        end
+
+        it 'get qualified alma record' do
+          expect(Util.qualified_alma_record?(qualified_alm_record)).to eq true
+        end
+
+        it 'get unqualified alma record' do
+          expect(Util.qualified_alma_record?(un_qualified_alm_record)).to eq false
+        end
+
+        it 'get symbol from string "a--a"' do
+          expect(Util.concatenation_symbol('a--a')).to eq ' -- '
+        end
+
+        it 'get symbol from nil' do
+          expect(Util.concatenation_symbol(nil)).to eq ' '
+        end
+
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/marc/xml_writer_spec.rb

@@ -187,6 +187,30 @@ module BerkeleyLibrary
               end
             end
           end
+
+          it 'writes to a Tempfile object' do
+            Dir.mktmpdir(File.basename(__FILE__, '.rb')) do |dir|
+              out = Tempfile.new(File.join(dir, 'marc.xml'))
+              begin
+                # noinspection RubyMismatchedArgumentType
+                w = XMLWriter.new(out)
+                w.write(record)
+                w.close
+
+                expected = File.open(input_path) { |f| Nokogiri::XML(f) }
+                actual = File.open(out.path) { |f| Nokogiri::XML(f) }
+              ensure
+                out.close
+                out.unlink
+              end
+
+              aggregate_failures do
+                EquivalentXml.equivalent?(expected, actual) do |n1, n2, result|
+                  expect(n2.to_s).to eq(n1.to_s) unless result
+                end
+              end
+            end
+          end
         end
       end
     end