berkeley_library-tind 0.5.1 → 0.7.0

data/lib/berkeley_library/tind/mapping/tind_subfield_util.rb

@@ -0,0 +1,154 @@
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      module TindSubfieldUtil
+
+        def clean_subfield(subfield)
+          new_value = clr_value(subfield.value)
+          subfield.value = new_value
+        end
+
+        def fields_880_subfield6(datafields_880)
+          formated_subfield6_value_arr(fields_by(datafields_880) { |f| is_880_field?(f) })
+        end
+
+        # From all subfield 6 gotten for repeated fields - with the same tag
+        # return the first subfield 6
+        def the_first_subfield6(fields)
+          values = subfield_6_values(fields)
+          return nil if values.empty?
+
+          # keep it here, in case needed in future: this can make sure
+          # 880 and regular fields having matching sequence number
+          # subfield6_with_small_no(values)
+
+          # new implementation: keep the first subfield 6 value
+          logger.warn("#{f[0].tag} have multiple datafields with multiple subfield 6, the first subfield 6 is kept") if values.length > 1
+          Util.subfield('6', values[0])
+        end
+
+        private
+
+        def subfield6?(f)
+          !f['6'].nil?
+        end
+
+        # f.tag can be a string or integer
+        def is_880_field?(f)
+          f.tag.to_s == '880'
+        end
+
+        # return subfield6 value formated the same way for both 880 and regular datafields
+        def formated_subfield6_value(f)
+          is_880_field?(f) ? formated_subfield6_from_880(f) : formated_subfield6_from_regular_field(f)
+        end
+
+        def fields_by(fields, &block)
+          fields.select(&block)
+        end
+
+        # return array of formated subfield6 values on inputted datafields
+        def formated_subfield6_value_arr(fields_source)
+          # fields_source = is_880_field ? fields_880(datafields) : fields_regular(datafields)
+          ls = []
+          fields_source.map do |f|
+            next unless subfield6?(f)
+
+            ls << formated_subfield6_value(f)
+          end
+          ls.compact
+        end
+
+        # return formated field6 for a regular datafield
+        # tag:246, subfields: 880-02 => 880-246-02
+        def formated_subfield6_from_regular_field(f)
+          return nil unless f['6']
+
+          tag = f.tag
+          arr = f['6'].strip.split('-')
+          "#{arr[0]}-#{tag}-#{arr[1]}"
+        end
+
+        # return formated subfield6 for a 880 datafield
+        # tag: 880, subfield6: 245-01/$1  => 880-245-01
+        def formated_subfield6_from_880(f)
+          return nil unless f['6']
+
+          "#{f.tag}-#{f['6'].strip[0, 6].strip}"
+        end
+
+        # return subfields of specific code
+        # Datafield returned from Alma may have mutiple subfields with the same code
+        def subfields(field, code)
+          sf = []
+          field.each do |s|
+            next unless s.code == code
+
+            captilize_subfield(s) if code == '3'
+            sf << s
+          end
+          sf
+        end
+
+        def captilize_subfield(subfield)
+          new_value = subfield.value.capitalize
+          subfield.value = new_value
+        end
+
+        # Combine multiple subfield values based on definition from csv file
+        def combined_subfield_value(field, code, symbol)
+          sf_arr = subfields(field, code)
+          return '' if sf_arr.empty?
+
+          sf_arr.map(&:value).join(symbol) << symbol # symbol exmaple ' -- '
+        end
+
+        # Mutilpe subfields in one field may have the same name
+        # Get all subfields on 'from subfield name'
+        # Change subfield names with 'to subfield name'
+        def subfields_from_to(field, from, to)
+          subfield_arr = subfields(field, from)
+          subfield_arr.each { |sf| sf.code = to } if !subfield_arr.empty? && (from != to)
+          subfield_arr
+        end
+
+        def subfield6_endwith_00?(f)
+          return false unless is_880_field?(f)
+
+          two_digits = f['6'].strip.split('-')[1][0..1]
+          two_digits.to_s == '00'
+        end
+
+        def fields_with_subfield6(fields)
+          fields.select { |f| subfield6?(f) }
+        end
+
+        # return subfield 6 with the smallest sequence number
+        def subfield_6_values(fields)
+          fields_with_subfield6(fields).map(&:value)
+        end
+
+        def subfield6_value_with_lowest_seq_no(values)
+          seq = 9999
+          txt = nil
+          values.each do |val|
+            num = seq_no(val)
+            if (num > 0) && (num < seq)
+              seq = num
+              txt = val
+            end
+          end
+          txt
+        end
+
+        # return all subfields except subfield6
+        def subfields_without_subfield6(field)
+          field.subfields.reject { |sf| sf.code == '6' }
+        end
+
+      end
+    end
+  end
+end

data/lib/berkeley_library/tind/mapping/util.rb

@@ -0,0 +1,136 @@
+require 'csv'
+require 'marc'
+require 'berkeley_library/tind/mapping/alma_base'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      module Util
+        include AlmaBase
+
+        class << self
+
+          def csv_rows(file)
+            rows = []
+            CSV.foreach(file, headers: true, header_converters: :symbol, encoding: 'bom|utf-8') do |row|
+              # puts row.headers
+              rows << clr_row(row)
+            end
+            rows
+          end
+
+          def concatenation_symbol(str)
+            str ? str.gsub('a', ' ') : ' '
+          end
+
+          def indicator(str)
+            return [] unless str
+
+            str.strip.gsub('_', ' ').split(',')
+          end
+
+          def tag_symbol(tag)
+            "tag_#{tag}".to_sym
+          end
+
+          def datafield(tag, indicator, subfields)
+            datafield = ::MARC::DataField.new(tag, indicator[0], indicator[1])
+            subfields.each { |sf| datafield.append(sf) }
+            datafield
+          end
+
+          def subfield(code, value)
+            ::MARC::Subfield.new(code, value)
+          end
+
+          def subfield_hash(field)
+            code_value_arr = field.to_hash[field.tag]['subfields']
+            {}.tap { |i| code_value_arr.each(&i.method(:update)) }
+          end
+
+          # input an array of rules, example: [["a,b,c,d", "b", "--"],["o,p,q", "b", ""]]
+          def symbols(rules)
+            rules.map { |rule| concatenation_symbol(rule[2]).strip }
+          end
+
+          def remove_extra_symbol(rules, val)
+            symbols = symbols(rules)
+            symbols.each { |s| val = val.strip.delete_suffix(s) }
+            val
+          end
+
+          def alma_datafield(tag, record)
+            record.fields.each { |f| return f if f.tag.to_s == tag }
+            nil
+          end
+
+          def qualified_alma_record?(alma_record)
+            f_245 = alma_datafield('245', alma_record)
+            f_245_a = f_245['a'].downcase
+
+            val = 'Host bibliographic record'.downcase
+            !f_245_a.start_with? val
+          end
+
+          # From DM - get testing MARC from xml file
+          # @param xml [String] the XML to parse
+          # @return [MARC::Record, nil] the MARC record from the specified XML
+          def from_xml(xml)
+            # noinspection RubyYardReturnMatch,RubyMismatchedReturnType
+            all_from_xml(xml).first
+          end
+
+          def collection_config_correct?
+            no_including = BerkeleyLibrary::TIND::Mapping::AlmaBase.including_origin_tags.empty?
+            no_excluding = BerkeleyLibrary::TIND::Mapping::AlmaBase.excluding_origin_tags.empty?
+            no_including || no_excluding
+          end
+
+          # subfield util
+          def order_subfields(subfields, codes)
+            found_subfields = []
+            codes.each do |code|
+              sfs = subfields.select { |subfield| subfield.code == code }
+              found_subfields.concat sfs
+            end
+            not_found_subfields = subfields - found_subfields
+            found_subfields.concat not_found_subfields
+          end
+
+          private
+
+          def clr_row(row)
+            row[:tag_origin] = format_tag(row[:tag_origin])
+            row[:tag_destination] = format_tag(row[:tag_destination])
+            row[:map_if_no_this_tag_existed] = format_tag(row[:map_if_no_this_tag_existed])
+            row
+          end
+
+          # To ensure tag from csv file in three digits
+          def format_tag(tag)
+            # LDR is not a numeric tag
+            return tag unless numeric? tag
+
+            format('%03d', tag)
+          end
+
+          def numeric?(str)
+            return false if str.nil?
+
+            str.scan(/\D/).empty?
+          end
+
+          # Parses MARCXML.
+          #
+          # @param xml [String] the XML to parse
+          # @return [MARC::XMLReader] the MARC records
+          def all_from_xml(xml)
+            input = StringIO.new(xml.scrub)
+            MARC::XMLReader.new(input)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/tind/mapping.rb

@@ -0,0 +1 @@
+Dir.glob(File.expand_path('mapping/*.rb', __dir__)).sort.each(&method(:require))

data/lib/berkeley_library/tind/module_info.rb

@@ -7,7 +7,7 @@ module BerkeleyLibrary
       SUMMARY = 'TIND DA utilities for the UC Berkeley Library'.freeze
       DESCRIPTION = 'UC Berkeley Library utility gem for working with the TIND DA digital archive.'.freeze
       LICENSE = 'MIT'.freeze
-      VERSION = '0.5.1'.freeze
+      VERSION = '0.7.0'.freeze
       HOMEPAGE = 'https://github.com/BerkeleyLibrary/tind'.freeze
     end
   end

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe AdditionalDatafieldProcess 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(:tindfields) { tind_marc.tindfields }
+        let(:additona_245_field) { [Util.datafield('245', [' ', ' '], [Util.subfield('a', 'fake 245 a')])] }
+        let(:with_repeated_fields) { tindfields.concat additona_245_field }
+
+        context '# Process 1: Remove duplicated fields' do
+          # two 245 fields inputed, one is removed
+          it 'Input two 245 fields, return only one 245 field' do
+            expect(tind_marc.remove_repeats(with_repeated_fields).map(&:tag).count('245')).to eq 1
+          end
+
+          # one subfield 'a' is kept, subfield 'a' with a value of 'fake 245 a' is ignored
+          it 'Input two subfield $a, keeping the first one' do
+            without_repeated_fields = tind_marc.remove_repeats(with_repeated_fields)
+            single_field_245 = tind_marc.field_on_tag('245', without_repeated_fields)
+            expect(single_field_245['a']).to eq 'Cang jie pian'
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+require 'spec_helper'
+require 'tempfile'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      describe AlmaBase do
+        extend BerkeleyLibrary::Logging
+        let(:dummy_obj) { Class.new { extend AlmaBase } }
+        let(:alma_record) { ::MARC::Record.new }
+        let(:save_to_file) { Tempfile.new('xml') }
+        let(:record_id) { Class.new { extend BerkeleyLibrary::Alma::RecordId } }
+        let(:hash) { { '980' => ['pre_1912'] } }
+
+        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 }
+
+        describe '# base_tind_record' do
+          it 'input a qualified Alma record - return a tind record' do
+            allow(dummy_obj).to receive(:tind_record).with('C084093187', qualified_alm_record, []).and_return(::MARC::Record.new)
+            expect(dummy_obj.base_tind_record('C084093187', [], qualified_alm_record)).to be_a ::MARC::Record
+          end
+
+          it 'input an unqualified Alma record - return nil' do
+            expect { dummy_obj.base_tind_record('C084093187', [], un_qualified_alm_record) }.to raise_error(ArgumentError)
+          end
+
+          it 'no input Alma record with a nil (record) from id  - return nil' do
+            allow(dummy_obj).to receive(:alma_record_from).with('C084093187').and_return(nil)
+            expect { dummy_obj.base_tind_record('C084093187', []) }.to raise_error(ArgumentError)
+          end
+        end
+
+        describe '# base_save' do
+          it 'save tind record' do
+            dummy_obj.base_save('C084093187', qualified_alm_record, save_to_file)
+            expect(File.open(save_to_file.path).readlines[0]).to eq "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+          end
+        end
+
+        describe '# alma_record' do
+          it 'get Alma record' do
+            allow(record_id).to receive(:get_marc_record).and_return(::MARC::Record.new)
+            allow(dummy_obj).to receive(:get_record_id).with('C084093187').and_return(record_id)
+            expect(dummy_obj.send(:alma_record_from, 'C084093187')).to be_instance_of ::MARC::Record
+          end
+        end
+
+        describe '# get_record_id' do
+          it 'return BerkeleyLibrary::Alma::BarCode' do
+            BerkeleyLibrary::TIND::Mapping::AlmaBase.is_barcode = true
+            expect(dummy_obj.send(:get_record_id, 'C084093187')).to be_instance_of BerkeleyLibrary::Alma::BarCode
+          end
+
+          it 'return BerkeleyLibrary::Alma::MMSID' do
+            BerkeleyLibrary::TIND::Mapping::AlmaBase.is_barcode = false
+            expect(dummy_obj.send(:get_record_id, '991085821143406532')).to be_instance_of BerkeleyLibrary::Alma::MMSID
+
+          end
+
+          it 'return BerkeleyLibrary::Alma::BibNumber' do
+            BerkeleyLibrary::TIND::Mapping::AlmaBase.is_barcode = false
+            expect(dummy_obj.send(:get_record_id, 'b11082434')).to be_instance_of BerkeleyLibrary::Alma::BibNumber
+
+          end
+        end
+
+        describe '# add_f_035' do
+          it 'Add 035 from mms_id' do
+            BerkeleyLibrary::TIND::Mapping::AlmaBase.is_035_from_mms_id = true
+            expect(dummy_obj.send(:add_f_035, '991085821143406532', hash).tag).to eq '035'
+          end
+
+          it 'Not to add 035 from mms_id' do
+            BerkeleyLibrary::TIND::Mapping::AlmaBase.is_035_from_mms_id = false
+            expect(dummy_obj.send(:add_f_035, '991085821143406532', hash)).to eq nil
+          end
+        end
+
+        describe '# tind_record, # derived_tind_fields' do
+          BerkeleyLibrary::TIND::Mapping::AlmaBase.collection_parameter_hash = {
+            '336' => ['Image'],
+            '852' => ['East Asian Library'],
+            '980' => ['pre_1912'],
+            '982' => ['Pre 1912 Chinese Materials - short name', 'Pre 1912 Chinese Materials - long name'],
+            '991' => []
+          }
+          let(:id) { '991085821143406532' }
+          let(:tags) { %w[902 336 852 980 982 901 856] }
+          let(:tags_with_035) { %w[902 336 852 980 982 901 856 035] }
+
+          it ' get tind_record' do
+            datafields = []
+            marc_record = qualified_alm_record
+            expect(dummy_obj.send(:tind_record, id, marc_record, datafields)).to be_instance_of ::MARC::Record
+          end
+
+          it 'get derived fields without 035' do
+            expect(dummy_obj.send(:derived_tind_fields, id).map(&:tag)).to eq tags
+          end
+
+          it 'get derived fields with 035' do
+            BerkeleyLibrary::TIND::Mapping::AlmaBase.is_035_from_mms_id = true
+            expect(dummy_obj.send(:derived_tind_fields, id).map(&:tag)).to eq tags_with_035
+          end
+
+        end
+
+      end
+    end
+  end
+end

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