libis-tools 1.0.5-java

data/spec/mets_file_spec.rb

@@ -0,0 +1,223 @@
+# encoding: utf-8
+require_relative 'spec_helper'
+require 'rspec/matchers'
+require 'equivalent-xml'
+require 'libis/tools/mets_file'
+require 'libis/tools/xml_document'
+
+describe 'METS File' do
+
+  before(:all) do
+    ::Libis::Tools::Config << {appname: 'LIBIS Default'}
+  end
+
+  subject(:mets_file) { ::Libis::Tools::MetsFile.new }
+
+  context 'without data' do
+
+    let(:skeleton) {
+      ::Libis::Tools::XmlDocument.build do |xml|
+        # noinspection RubyResolve
+        xml[:mets].mets 'xmlns:mets' => 'http://www.loc.gov/METS/' do
+          xml[:mets].amdSec 'ID' => 'ie-amd'
+          xml[:mets].fileSec
+        end
+      end.document
+    }
+
+    it 'generates skeleton XML' do
+      expect(mets_file.xml_doc.root).to be_equivalent_to skeleton.root
+    end
+
+  end
+
+  context 'with IE AMD' do
+
+    let(:dc_record) {
+      Libis::Tools::XmlDocument.parse <<-STR
+        <?xml version="1.0" encoding="UTF-8"?>
+        <record xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                xmlns:dc="http://purl.org/dc/elements/1.1/"
+                xmlns:dcterms="http://purl.org/dc/terms/">
+          <dc:title>Title</dc:title>
+          <dc:author>Author</dc:author>
+          <dc:subject>Subject</dc:subject>
+        </record>
+      STR
+    }
+
+    let(:marc_record) {
+      Libis::Tools::XmlDocument.parse <<-STR
+        <?xml version="1.0" encoding="UTF-8"?>
+        <record xsi:schemaLocation="http://www.loc.gov/MARC21/slim http://www.loc.gov/standards/marcxml/schema/MARC21slim.xsd"
+          xmlns="http://www.loc.gov/MARC21/slim" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+          <leader>abcdefghiljklmnopqrstuvwxyz</leader>
+          <controlfield tag="001">1234567890</controlfield>
+          <datafield tag="010" ind1="a" ind2="b">
+            <subfield code="a">abc</subfield>
+            <subfield code="b">xyz</subfield>
+          </datafield>
+        </record>
+        STR
+    }
+
+    let(:src_record) {
+      Libis::Tools::XmlDocument.parse <<-STR
+        <my_description xmlns="http://www.libis.be/description/">
+          <title>Title</title>
+          <importance>high</importance>
+          <location>here</location>
+        </my_description>
+        STR
+    }
+
+    let(:target) {
+      # noinspection RubyResolve
+      ::Libis::Tools::XmlDocument.build do |xml|
+        # noinspection RubyResolve
+        xml[:mets].mets 'xmlns:mets' => 'http://www.loc.gov/METS/' do
+          # noinspection RubyResolve
+          xml[:mets].amdSec ID: 'ie-amd' do
+            # noinspection RubyResolve
+            xml[:mets].techMD ID: 'ie-amd-tech' do
+              # noinspection RubyResolve
+              xml[:mets].mdWrap MDTYPE: 'OTHER', OTHERMDTYPE: 'dnx' do
+                # noinspection RubyResolve
+                xml[:mets].xmlData do
+                  xml.dnx xmlns: 'http://www.exlibrisgroup.com/dps/dnx' do
+                    # noinspection RubyResolve
+                    xml.section.objectCharacteristics! do
+                      xml.record do
+                        # noinspection RubyResolve
+                        xml.key.groupID! 'group_id'
+                      end
+                    end
+                    # noinspection RubyResolve
+                    xml.section.generalIECharacteristics! do
+                      # noinspection RubyResolve
+                      xml.record do
+                        xml.key.status! 'status'
+                        xml.key.IEEntityType! 'entity_type'
+                        xml.key.UserDefinedA! 'user_a'
+                        xml.key.UserDefinedB! 'user_b'
+                        xml.key.UserDefinedC! 'user_c'
+                        xml.key.submissionReason! 'submission_reason'
+                      end
+                    end
+                    # noinspection RubyResolve
+                    xml.section.retentionPolicy! do
+                      # noinspection RubyResolve
+                      xml.record do
+                        xml.key.policyId! 'retention_id'
+                      end
+                    end
+                    # noinspection RubyResolve
+                    xml.section.webHarvesting! do
+                      # noinspection RubyResolve
+                      xml.record do
+                        xml.key.primarySeedURL! 'harvest_url'
+                        xml.key.WCTIdentifier! 'harvest_id'
+                        xml.key.targetName! 'harvest_target'
+                        xml.key.group! 'harvest_group'
+                        xml.key.harvestDate! 'harvest_date'
+                        xml.key.harvestTime! 'harvest_time'
+                      end
+                    end
+                  end
+                end
+              end
+            end
+            # noinspection RubyResolve
+            xml[:mets].rightsMD ID: 'ie-amd-rights' do
+              # noinspection RubyResolve
+              xml[:mets].mdWrap MDTYPE: 'OTHER', OTHERMDTYPE: 'dnx' do
+                # noinspection RubyResolve
+                xml[:mets].xmlData do
+                  xml.dnx xmlns: 'http://www.exlibrisgroup.com/dps/dnx' do
+                    # noinspection RubyResolve
+                    xml.section.accessRightsPolicy! do
+                      # noinspection RubyResolve
+                      xml.record do
+                        xml.key.policyId! 'access_right'
+                      end
+                    end
+                  end
+                end
+              end
+            end
+            # noinspection RubyResolve
+            xml[:mets].sourceMD ID: 'ie-amd-source-DC-1' do
+              # noinspection RubyResolve
+              xml[:mets].mdWrap MDTYPE: 'DC' do
+                # noinspection RubyResolve
+                xml[:mets].xmlData do
+                  # xml.parent.namespace = xml.parent.namespace_definitions.first
+                  xml.parent << dc_record.root.to_xml
+                end
+              end
+            end
+            # noinspection RubyResolve
+            xml[:mets].sourceMD ID: 'ie-amd-source-MARC-2' do
+              # noinspection RubyResolve
+              xml[:mets].mdWrap MDTYPE: 'MARC' do
+                # noinspection RubyResolve
+                xml[:mets].xmlData do
+                  # xml.parent.namespace = xml.parent.namespace_definitions.first
+                  xml.parent << marc_record.root.to_xml
+                end
+              end
+            end
+            # noinspection RubyResolve
+            xml[:mets].sourceMD ID: 'ie-amd-source-OTHER-3' do
+              # noinspection RubyResolve
+              xml[:mets].mdWrap MDTYPE: 'OTHER' do
+                # noinspection RubyResolve
+                xml[:mets].xmlData do
+                  # xml.namespace = xml.parent.namespace_definitions.first
+                  xml.parent << src_record.root.to_xml
+                end
+              end
+            end
+          end
+          xml[:mets].fileSec
+        end
+      end.document
+    }
+
+    it 'fills in IE-AMD section' do
+      mets_file.amd_info = {
+          group_id: 'group_id',
+          status: 'status',
+          entity_type: 'entity_type',
+          user_a: 'user_a',
+          user_b: 'user_b',
+          user_c: 'user_c',
+          submission_reason: 'submission_reason',
+          retention_id: 'retention_id',
+          harvest_url: 'harvest_url',
+          harvest_id: 'harvest_id',
+          harvest_target: 'harvest_target',
+          harvest_group: 'harvest_group',
+          harvest_date: 'harvest_date',
+          harvest_time: 'harvest_time',
+          access_right: 'access_right',
+          source_metadata: [
+              {
+                  type: 'DC',
+                  data: dc_record.root.to_xml
+              }, {
+                  type: 'Marc',
+                  data: marc_record.root.to_xml
+              }, {
+                  type: 'other',
+                  data: src_record.root.to_xml
+              }
+          ]
+      }
+
+      expect(mets_file.xml_doc.root).to be_equivalent_to target.root
+
+    end
+  end
+
+end

data/spec/parameter_container_spec.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+require_relative 'spec_helper'
+require 'libis/tools/parameter'
+
+describe 'ParameterContainer' do
+
+  class TestContainer
+    include ::Libis::Tools::ParameterContainer
+
+    parameter check: true, description: 'check parameter'
+    parameter count: 0, description: 'count parameter'
+    parameter price: 1.0, description: 'price parameter'
+    parameter name: 'nobody', description: 'name parameter'
+    parameter calendar: Date.new(2014, 01, 01)
+    parameter clock: Time.parse('10:10')
+    parameter timestamp: DateTime.new(2014, 01, 01, 10, 10)
+    parameter with_options: true, options: {a: 1, b: 2}, c: 3
+
+  end
+
+  class DerivedContainer < TestContainer
+    parameter name: 'somebody', description: 'derived name parameter', frozen: true
+    parameter check: 'no'
+    parameter new_derived_param: false
+  end
+
+  class DerivedDerivedContainer < DerivedContainer
+    parameter price: 2.0, description: 'derived derived price parameter'
+  end
+
+  class DerivedDerivedDerivedContainer < DerivedDerivedContainer
+    parameter price: 3.0, description: 'derived derived derived price parameter'
+  end
+
+  let(:test_container) { TestContainer.new }
+  let(:derived_container) { DerivedContainer.new }
+  let(:derived_derived_container) { DerivedDerivedContainer.new }
+  let(:derived_derived_derived_container) { DerivedDerivedDerivedContainer.new }
+
+  it 'class should return parameter if only name is given' do
+    [:check, :count, :price, :name, :calendar, :clock, :timestamp].each do |v|
+      expect(TestContainer.parameter(v)).to be_a ::Libis::Tools::Parameter
+    end
+  end
+
+  it 'should have default parameters' do
+    expect(test_container.parameter(:check)).to be_truthy
+    expect(test_container.parameter(:count)).to eq 0
+    expect(test_container.parameter(:price)).to eq 1.0
+    expect(test_container.parameter(:name)).to eq 'nobody'
+    expect(test_container.parameter(:calendar).year).to eq 2014
+    expect(test_container.parameter(:calendar).month).to eq 1
+    expect(test_container.parameter(:calendar).day).to eq 1
+    expect(test_container.parameter(:clock).hour).to eq 10
+    expect(test_container.parameter(:clock).min).to eq 10
+    expect(test_container.parameter(:clock).sec).to eq 0
+    expect(test_container.parameter(:timestamp).year).to eq 2014
+    expect(test_container.parameter(:timestamp).month).to eq 1
+    expect(test_container.parameter(:timestamp).day).to eq 1
+    expect(test_container.parameter(:timestamp).hour).to eq 10
+    expect(test_container.parameter(:timestamp).min).to eq 10
+    expect(test_container.parameter(:timestamp).sec).to eq 0
+  end
+
+  it 'should allow to set values' do
+    test_container.parameter(:check, false)
+    expect(test_container.parameter(:check)).to be_falsey
+
+    test_container.parameter(:count, 99)
+    expect(test_container.parameter(:count)).to eq 99
+
+    test_container.parameter(:price, 99.99)
+    expect(test_container.parameter(:price)).to eq 99.99
+
+    test_container.parameter(:name, 'everybody')
+    expect(test_container.parameter(:name)).to eq 'everybody'
+
+    test_container.parameter(:calendar, Date.new(2015, 02, 03))
+    expect(test_container.parameter(:calendar).year).to eq 2015
+    expect(test_container.parameter(:calendar).month).to eq 2
+    expect(test_container.parameter(:calendar).day).to eq 3
+
+    test_container.parameter(:clock, Time.parse('14:40:23'))
+    expect(test_container.parameter(:clock).hour).to eq 14
+    expect(test_container.parameter(:clock).min).to eq 40
+    expect(test_container.parameter(:clock).sec).to eq 23
+
+    test_container.parameter(:timestamp, DateTime.new(2015, 02, 03, 14, 40, 23))
+    expect(test_container.parameter(:timestamp).year).to eq 2015
+    expect(test_container.parameter(:timestamp).month).to eq 2
+    expect(test_container.parameter(:timestamp).day).to eq 3
+    expect(test_container.parameter(:timestamp).hour).to eq 14
+    expect(test_container.parameter(:timestamp).min).to eq 40
+    expect(test_container.parameter(:timestamp).sec).to eq 23
+  end
+
+  it 'should be able to define parameter with options' do
+    expect(test_container.class.parameter(:with_options)[:options]).to eq a: 1, b: 2, c: 3
+    expect(test_container.class.parameter(:with_options)[:options][:a]).to be 1
+    expect(test_container.class.parameter(:with_options)[:a]).to be 1
+    expect(test_container.class.parameter(:with_options)[:options][:c]).to be 3
+    expect(test_container.class.parameter(:with_options)[:c]).to be 3
+  end
+
+  it 'derived class should inherit parameters of the parent class' do
+    expect(derived_container.parameter(:price)).to eq 1.0
+    expect(derived_container.class.parameter(:price)[:description]).to eq 'price parameter'
+  end
+
+  it 'derived class should override parameter values and propertiesfrom parent class' do
+    expect(derived_container.parameter(:name)).to eq 'somebody'
+    expect(derived_container.parameter(:check)).to eq 'no'
+  end
+
+  it 'overrides in the derived classes should not change values in the parent classes' do
+    expect(test_container.parameter(:check)).to eq true
+    expect(test_container.parameter(:price)).to eq 1.0
+    expect(test_container.class.parameter(:price)[:description]).to eq 'price parameter'
+  end
+
+  it 'derivation should be supported over multiple levels' do
+    expect(derived_container.parameter(:price)).to eq 1.0
+    expect(derived_derived_container.parameter(:price)).to eq 2.0
+    expect(derived_derived_derived_container.parameter(:price)).to eq 3.0
+    expect(derived_container.class.parameter(:price)[:description]).to eq 'price parameter'
+    expect(derived_derived_container.class.parameter(:price)[:description]).to eq 'derived derived price parameter'
+    expect(derived_derived_derived_container.class.parameter(:price)[:description]).to eq 'derived derived derived price parameter'
+  end
+
+  it 'frozen parameters should be read-only' do
+    expect {
+      derived_container.parameter(:name, 'anybody')
+    }.to raise_error(::Libis::Tools::ParameterFrozenError)
+    expect(derived_container.parameter(:name)).to eq 'somebody'
+    expect {
+      derived_container[:name] = 'anybody'
+    }.not_to raise_error
+    expect(derived_container[:name]).to eq 'somebody'
+  end
+
+  it 'frozen state should not affect parameter in parent class' do
+    expect {
+      test_container.parameter(:name, 'anybody')
+    }.not_to raise_error
+    expect(test_container.parameter(:name)).to eq 'anybody'
+    expect {
+      test_container[:name] = 'everybody'
+    }.not_to raise_error
+    expect(test_container[:name]).to eq 'everybody'
+  end
+
+end

data/spec/parameter_spec.rb

@@ -0,0 +1,148 @@
+# encoding: utf-8
+require_relative 'spec_helper'
+require 'libis/tools/parameter'
+
+describe 'Parameter' do
+
+  before :context do
+    @parameter_types = %w'bool string int float datetime'
+
+    @bool_parameter = ::Libis::Tools::Parameter.new('BoolParam', true)
+    @string_parameter = ::Libis::Tools::Parameter.new('StringParam', 'default string')
+    @int_parameter = ::Libis::Tools::Parameter.new('IntParam', 5)
+    @float_parameter = ::Libis::Tools::Parameter.new('FloatParam', 1.0)
+    @datetime_parameter = ::Libis::Tools::Parameter.new('DateTimeParam', DateTime.now)
+
+    @constrained_bool_parameter = ::Libis::Tools::Parameter.new('BoolParam', true, nil, nil, true)
+    @constrained_string_parameter = ::Libis::Tools::Parameter.new('StringParam', 'default string', nil, nil, /^ABC.*XYZ$/i)
+    @constrained_int_parameter = ::Libis::Tools::Parameter.new('IntParam', 5, nil, nil, [1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37])
+    @constrained_float_parameter = ::Libis::Tools::Parameter.new('FloatParam', 0.0, nil, nil, 1.0...3.1415927)
+  end
+
+  it 'should detect datatype from default value' do
+    @parameter_types.each do |dtype|
+      expect(eval("@#{dtype}_parameter").send(:guess_datatype)).to eq dtype
+    end
+  end
+
+  it 'should return default value' do
+    @parameter_types.each do |dtype|
+      expect(eval("@#{dtype}_parameter").parse).to eq eval("@#{dtype}_parameter").default
+    end
+  end
+
+  it 'should test if boolean value is valid' do
+    [false, true, nil, 'true', 'false', 'T', 'F', 'y', 'n', 1, 0].each do |v|
+      # noinspection RubyResolve
+      expect(@bool_parameter).to be_valid_value(v)
+    end
+
+    [5, 0.1, 'abc'].each do |v|
+      # noinspection RubyResolve
+      expect(@bool_parameter).not_to be_valid_value(v)
+    end
+  end
+
+  it 'should test if string value is valid' do
+    ['abc', true, false, nil, 1, 1.0, Object.new].each do |v|
+      # noinspection RubyResolve
+      expect(@string_parameter).to be_valid_value(v)
+    end
+  end
+
+  it 'should test if integer value is valid' do
+    [0, 5, -6, 3.1415926, '3', nil, Rational('1/3')].each do |v|
+      # noinspection RubyResolve
+      expect(@int_parameter).to be_valid_value(v)
+    end
+
+    ['abc', '3.1415926', '1 meter', false, true, Object.new].each do |v|
+      # noinspection RubyResolve
+      expect(@int_parameter).not_to be_valid_value(v)
+    end
+  end
+
+  it 'should test if float value is valid' do
+    [1.1, Rational('1/3'), 3.1415926, '3.1415926', nil].each do |v|
+      # noinspection RubyResolve
+      expect(@float_parameter).to be_valid_value(v)
+    end
+
+    ['abc', '1.0.0', false, true, Object.new].each do |v|
+      # noinspection RubyResolve
+      expect(@float_parameter).not_to be_valid_value(v)
+    end
+  end
+
+  it 'should test if datetime value is valid' do
+    [Time.now, Date.new, '10:10', '2014/01/01', '2014/01/01 10:10:10.000001', nil].each do |v|
+      # noinspection RubyResolve
+      expect(@datetime_parameter).to be_valid_value(v)
+    end
+
+    ['abc', 5, false].each do |v|
+      # noinspection RubyResolve
+      expect(@datetime_parameter).not_to be_valid_value(v)
+    end
+  end
+
+  it 'should accept and convert value for boolean parameter' do
+    ['true', 'True', 'TRUE','tRuE', 't', 'T', 'y', 'Y', '1', 1].each do |v|
+      expect(@bool_parameter.parse(v)).to be_truthy
+    end
+
+    ['false', 'False', 'FALSE','fAlSe', 'f', 'F', 'n', 'N', '0', 0].each do |v|
+      expect(@bool_parameter.parse(v)).to be_falsey
+    end
+  end
+
+  # noinspection RubyResolve
+  it 'should check values against constraint' do
+    expect(@constrained_bool_parameter).to be_valid_value(true)
+    expect(@constrained_bool_parameter).to be_valid_value('y')
+
+    expect(@constrained_bool_parameter).not_to be_valid_value(false)
+    expect(@constrained_bool_parameter).not_to be_valid_value('n')
+
+    %w'ABCXYZ ABC123XYZ abcxyz AbC__++__xYz'.each do |v|
+      # noinspection RubyResolve
+      expect(@constrained_string_parameter).to be_valid_value(v)
+    end
+
+    %w'ABC XYZ ABC123'.each do |v|
+      # noinspection RubyResolve
+      expect(@constrained_string_parameter).not_to be_valid_value(v)
+    end
+
+    [1, 7, 11, nil].each do |v|
+      # noinspection RubyResolve
+      expect(@constrained_int_parameter).to be_valid_value(v)
+    end
+
+    [0, 4, 9, 43].each do |v|
+      # noinspection RubyResolve
+      expect(@constrained_int_parameter).not_to be_valid_value(v)
+    end
+
+    [1.0, 3.1415, 2.718281828459].each do |v|
+      # noinspection RubyResolve
+      expect(@constrained_float_parameter).to be_valid_value(v)
+    end
+
+    [nil, 0.5, -2.5].each do |v|
+      # noinspection RubyResolve
+      expect(@constrained_float_parameter).not_to be_valid_value(v)
+    end
+
+  end
+
+  it 'should allow to set and get options' do
+
+    @bool_parameter[:my_value] = :dummy_value
+
+    expect(@bool_parameter[:my_value]).to be :dummy_value
+    expect(@bool_parameter[:options][:my_value]).to be :dummy_value
+
+  end
+
+end