qa 3.1.0 → 4.0.0.rc1

data/spec/models/iri_template/variable_map_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+RSpec.describe Qa::IriTemplate::VariableMap do
+  subject { described_class.new(map) }
+
+  let(:map) do
+    {
+      :"@type" => "IriTemplateMapping",
+      property: "hydra:freetextQuery",
+      variable: "subauth",
+      required: true
+    }
+  end
+
+  describe 'model attributes' do
+    it { is_expected.to respond_to :variable }
+    it { is_expected.to respond_to :simple_value }
+    # it { is_expected.to respond_to :parameter_value }
+  end
+
+  describe '#new' do
+    context 'when variable is missing' do
+      before do
+        map.delete(:variable)
+      end
+
+      it 'raises an error' do
+        expect { described_class.new(map) }.to raise_error(Qa::InvalidConfiguration, 'variable is required')
+      end
+    end
+
+    context 'when invalid required value' do
+      before do
+        map[:required] = 'BAD_REQUIRED'
+      end
+
+      it 'raises an error' do
+        expect { described_class.new(map) }.to raise_error(Qa::InvalidConfiguration, 'required must be true or false')
+      end
+    end
+  end
+
+  describe '#variable' do
+    it 'returns the configured variable' do
+      expect(subject.variable).to eq 'subauth'
+    end
+  end
+
+  describe '#simple_value' do
+    context 'when sub_value is not passed in' do
+      context 'and default is not defined' do
+        context 'and variable is required' do
+          before do
+            map[:required] = true
+          end
+
+          it 'raises error' do
+            expect { subject.simple_value }.to raise_error(StandardError, 'subauth is required, but missing')
+          end
+        end
+
+        context 'and variable is not required' do
+          before do
+            map[:required] = false
+          end
+
+          it 'returns empty string' do
+            expect(subject.simple_value).to eq ''
+          end
+        end
+      end
+
+      context 'and default is defined' do
+        before do
+          map[:required] = false
+          map[:default] = 'personal_name'
+        end
+
+        it 'returns the default' do
+          expect(subject.simple_value).to eq 'personal_name'
+        end
+      end
+    end
+
+    context 'when sub_value is passed in' do
+      before do
+        map[:required] = true
+      end
+
+      it 'returns passed in sub_value' do
+        expect(subject.simple_value('corporate_name')).to eq 'corporate_name'
+      end
+    end
+
+    context 'when sub_value should be encoded' do
+      before do
+        map[:encode] = true
+      end
+
+      it 'returns encoded sub_value' do
+        expect(subject.simple_value('http://example.org/over/the_rainbow')).to eq 'http%3A%2F%2Fexample%2Eorg%2Fover%2Fthe_rainbow'
+      end
+    end
+  end
+end

data/spec/models/linked_data/config/context_map_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+RSpec.describe Qa::LinkedData::Config::ContextMap do
+  subject { described_class.new(context_map) }
+
+  before do
+    # simulate the existence of the i18n entries
+    allow(I18n).to receive(:t).and_call_original
+  end
+
+  let(:context_map) do
+    {
+      groups: {
+        dates: {
+          group_label_i18n: 'qa.linked_data.authority.locnames_ld4l_cache.dates',
+          group_label_default: 'default_Dates'
+        }
+      },
+      properties: [
+        {
+          property_label_i18n: 'qa.linked_data.authority.locgenres_ld4l_cache.authoritative_label',
+          property_label_default: 'default_Authoritative Label',
+          ldpath: 'madsrdf:authoritativeLabel',
+          selectable: true,
+          drillable: false
+        },
+        {
+          group_id: 'dates',
+          property_label_i18n: 'qa.linked_data.authority.locnames_ld4l_cache.birth_date',
+          property_label_default: 'default_Birth',
+          ldpath: 'madsrdf:identifiesRWO/madsrdf:birthDate/schema:label',
+          selectable: false,
+          drillable: false
+        },
+        {
+          group_id: 'dates',
+          property_label_i18n: 'qa.linked_data.authority.locnames_ld4l_cache.death_date',
+          property_label_default: 'default_Death',
+          ldpath: 'madsrdf:identifiesRWO/madsrdf:deathDate/schema:label',
+          selectable: false,
+          drillable: false
+        }
+      ]
+    }
+  end
+
+  let(:prefixes) do
+    {
+      schema: "http://www.w3.org/2000/01/rdf-schema#",
+      skos: "http://www.w3.org/2004/02/skos/core#"
+    }
+  end
+
+  describe '#new' do
+    it 'accepts a single parameter for context_map' do
+      expect(subject).to be_kind_of described_class
+    end
+
+    it 'accepts required context_map parameter and optional prefixes parameter' do
+      expect(described_class.new(context_map, prefixes)).to be_kind_of described_class
+    end
+  end
+
+  describe '#properties' do
+    it 'returns the configured url template' do
+      expect(subject.properties.size).to eq 3
+      expect(subject.properties.first).to be_kind_of Qa::LinkedData::Config::ContextPropertyMap
+    end
+  end
+
+  describe '#group_label' do
+    context 'when map defines group_label_i18n key' do
+      context 'and i18n translation is defined in locales' do
+        before do
+          allow(I18n).to receive(:t).with('qa.linked_data.authority.locnames_ld4l_cache.dates', default: 'default_Dates').and_return('Dates')
+        end
+
+        it 'returns the translated text' do
+          expect(subject.group_label(:dates)).to eq 'Dates'
+        end
+      end
+
+      context 'and i18n translation is NOT defined in locales' do
+        context 'and default is defined in the map' do
+          before do
+            allow(I18n).to receive(:t).with('qa.linked_data.authority.locnames_ld4l_cache.dates', default: 'default_Dates').and_return('default_Dates')
+          end
+
+          it 'returns the default value' do
+            expect(subject.group_label(:dates)).to eq 'default_Dates'
+          end
+        end
+
+        context 'and default is NOT defined in the map' do
+          let(:groups) do
+            {
+              dates: {
+                group_label_i18n: 'qa.linked_data.authority.locnames_ld4l_cache.dates'
+              }
+            }
+          end
+          before do
+            context_map[:groups] = groups
+            allow(I18n).to receive(:t).with('qa.linked_data.authority.locnames_ld4l_cache.dates', nil).and_return(nil)
+          end
+
+          it 'returns nil' do
+            expect(subject.group_label(:dates)).to eq nil
+          end
+        end
+      end
+    end
+
+    context 'when map does NOT define group_label_i18n key' do
+      context 'and default is defined in map' do
+        let(:groups) do
+          {
+            dates: {
+              group_label_default: 'default_Dates'
+            }
+          }
+        end
+        before do
+          context_map[:groups] = groups
+        end
+
+        it 'returns the default value' do
+          expect(subject.group_label(:dates)).to eq 'default_Dates'
+        end
+      end
+
+      context 'and default is NOT defined in map' do
+        let(:groups) do
+          {
+            dates: {}
+          }
+        end
+        before do
+          context_map[:groups] = groups
+        end
+
+        it 'returns nil' do
+          expect(subject.group_label(:dates)).to eq nil
+        end
+      end
+    end
+  end
+end

data/spec/models/linked_data/config/context_property_map_spec.rb

@@ -0,0 +1,286 @@
+require 'spec_helper'
+
+RSpec.describe Qa::LinkedData::Config::ContextPropertyMap do
+  subject { described_class.new(property_map) }
+
+  let(:property_map) do
+    {
+      group_id: 'dates',
+      property_label_i18n: 'qa.linked_data.authority.locnames_ld4l_cache.birth_date',
+      property_label_default: 'default_Birth',
+      ldpath: 'madsrdf:identifiesRWO/madsrdf:birthDate/schema:label',
+      selectable: false,
+      drillable: false,
+      expansion_label_ldpath: 'skos:prefLabel ::xsd:string',
+      expansion_id_ldpath: 'loc:lccn ::xsd:string'
+    }
+  end
+
+  let(:prefixes) do
+    {
+      schema: 'http://www.w3.org/2000/01/rdf-schema#',
+      skos: 'http://www.w3.org/2004/02/skos/core#'
+    }
+  end
+
+  describe '#new' do
+    context 'when ldpath is missing' do
+      before { property_map.delete(:ldpath) }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(Qa::InvalidConfiguration, 'ldpath is required')
+      end
+    end
+
+    context 'when invalid selectable value' do
+      before { property_map[:selectable] = 'INVALID' }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(Qa::InvalidConfiguration, 'selectable must be true or false')
+      end
+    end
+
+    context 'when invalid drillable value' do
+      before { property_map[:drillable] = 'INVALID' }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(Qa::InvalidConfiguration, 'drillable must be true or false')
+      end
+    end
+
+    it 'accepts a single parameter for property_map' do
+      expect(subject).to be_kind_of described_class
+    end
+
+    it 'accepts required property_map parameter and optional prefixes parameter' do
+      expect(described_class.new(property_map, prefixes)).to be_kind_of described_class
+    end
+  end
+
+  describe '#selectable?' do
+    context 'when map has selectable: true' do
+      before { property_map[:selectable] = true }
+
+      it 'returns true' do
+        expect(subject.selectable?).to be true
+      end
+    end
+
+    context 'when map has selectable: false' do
+      before { property_map[:selectable] = false }
+
+      it 'returns false' do
+        expect(subject.selectable?).to be false
+      end
+    end
+
+    context 'when selectable: is not defined in the map' do
+      before { property_map.delete(:selectable) }
+
+      it 'returns false' do
+        expect(subject.selectable?).to be false
+      end
+    end
+  end
+
+  describe '#drillable?' do
+    context 'when map has drillable: true' do
+      before { property_map[:drillable] = true }
+
+      it 'returns true' do
+        expect(subject.drillable?).to be true
+      end
+    end
+
+    context 'when map has drillable: false' do
+      before { property_map[:drillable] = false }
+
+      it 'returns false' do
+        expect(subject.drillable?).to be false
+      end
+    end
+
+    context 'when drillable: is not defined in the map' do
+      before { property_map.delete(:drillable) }
+
+      it 'returns false' do
+        expect(subject.drillable?).to be false
+      end
+    end
+  end
+
+  describe '#label' do
+    context 'when map defines property_label_i18n key' do
+      context 'and i18n translation is defined in locales' do
+        before do
+          allow(I18n).to receive(:t).with('qa.linked_data.authority.locnames_ld4l_cache.birth_date', default: 'default_Birth').and_return('Birth')
+        end
+
+        it 'returns the translated text' do
+          expect(subject.label).to eq 'Birth'
+        end
+      end
+
+      context 'and i18n translation is NOT defined in locales' do
+        context 'and default is defined in the map' do
+          before do
+            allow(I18n).to receive(:t).with('qa.linked_data.authority.locnames_ld4l_cache.birth_date', default: 'default_Birth').and_return('default_Birth')
+          end
+
+          it 'returns the default value' do
+            expect(subject.label).to eq 'default_Birth'
+          end
+        end
+
+        context 'and default is NOT defined in the map' do
+          before do
+            property_map.delete(:property_label_default)
+            allow(I18n).to receive(:t).with('qa.linked_data.authority.locnames_ld4l_cache.birth_date', default: nil).and_return(nil)
+          end
+
+          it 'returns nil' do
+            expect(subject.label).to eq nil
+          end
+        end
+      end
+    end
+
+    context 'when map does NOT define property_label_i18n key' do
+      before { property_map.delete(:property_label_i18n) }
+
+      context 'and default is defined in map' do
+        it 'returns the default value' do
+          expect(subject.label).to eq 'default_Birth'
+        end
+      end
+
+      context 'and default is NOT defined in map' do
+        before { property_map.delete(:property_label_default) }
+
+        it 'returns nil' do
+          expect(subject.label).to eq nil
+        end
+      end
+    end
+  end
+
+  describe '#group_id' do
+    context 'when map defines group_id' do
+      it 'returns group_id as a symbol' do
+        expect(subject.group_id).to eq :dates
+      end
+    end
+
+    context 'when map does NOT define group_id' do
+      before { property_map.delete(:group_id) }
+
+      it 'returns nil' do
+        expect(subject.group_id).to eq nil
+      end
+    end
+  end
+
+  describe '#group?' do
+    context 'when map defines group_id' do
+      it 'returns true' do
+        expect(subject.group?).to be true
+      end
+    end
+
+    context 'when map does NOT define group_id' do
+      before { property_map.delete(:group_id) }
+
+      it 'returns false' do
+        expect(subject.group?).to be false
+      end
+    end
+  end
+
+  describe '#values' do
+    let(:program) { instance_double(Ldpath::Program) }
+    let(:coordinates) { '42.4488° N, 76.4763° W' }
+    let(:subject_uri) { instance_double(RDF::URI) }
+    let(:graph) { instance_double(RDF::Graph) }
+
+    before do
+      allow(Ldpath::Program).to receive(:parse).with(anything).and_return(program)
+      allow(program).to receive(:evaluate).with(anything, anything).and_return('property' => [coordinates, coordinates, coordinates]) # check that uniq is applied
+    end
+    it 'returns the values selected from the graph' do
+      expect(subject.values(graph, subject_uri)).to match_array coordinates
+    end
+
+    context 'when ldpath_program gets parse error' do
+      let(:ldpath) { property_map[:ldpath] }
+      let(:cause) { "undefined method `ascii_tree' for nil:NilClass" }
+      let(:warning) { I18n.t('qa.linked_data.ldpath.parse_logger_error') }
+      let(:log_message) { "WARNING: #{warning} (ldpath='#{ldpath}')\n    cause: #{cause}" }
+
+      before { allow(Ldpath::Program).to receive(:parse).with(anything).and_raise(cause) }
+
+      it 'logs error and returns PARSE ERROR as the value' do
+        expect(Rails.logger).to receive(:warn).with(log_message)
+        expect { subject.values(graph, subject_uri) }.to raise_error StandardError, I18n.t('qa.linked_data.ldpath.parse_error')
+      end
+    end
+
+    context 'when ldpath_evaluate gets parse error' do
+      let(:ldpath) { property_map[:ldpath] }
+      let(:cause) { "unknown cause" }
+      let(:warning) { I18n.t('qa.linked_data.ldpath.evaluate_logger_error') }
+      let(:log_message) { "WARNING: #{warning} (ldpath='#{ldpath}')\n    cause: #{cause}" }
+
+      before { allow(program).to receive(:evaluate).with(subject_uri, graph).and_raise(cause) }
+
+      it 'logs error and returns PARSE ERROR as the value' do
+        expect(Rails.logger).to receive(:warn).with(log_message)
+        expect { subject.values(graph, subject_uri) }.to raise_error StandardError, I18n.t('qa.linked_data.ldpath.evaluate_error')
+      end
+    end
+  end
+
+  describe '#expand_uri?' do
+    context 'when map has a value for expansion_label_ldpath' do
+      it 'returns true' do
+        expect(subject.expand_uri?).to be true
+      end
+    end
+
+    context 'when map does NOT have a value for expansion_label_ldpath' do
+      before { property_map.delete(:expansion_label_ldpath) }
+
+      it 'returns false' do
+        expect(subject.expand_uri?).to be false
+      end
+    end
+  end
+
+  describe '#expanded_values' do
+    let(:graph) { instance_double(RDF::Graph) }
+    let(:subject_uri) { instance_double(RDF::URI) }
+
+    let(:basic_program) { instance_double(Ldpath::Program) }
+    let(:expanded_label_program) { instance_double(Ldpath::Program) }
+    let(:expanded_id_program) { instance_double(Ldpath::Program) }
+
+    let(:expanded_uri) { instance_double(RDF::URI) }
+    let(:expanded_label) { 'A Broader Term' }
+    let(:expanded_id) { '123' }
+
+    before do
+      allow(Ldpath::Program).to receive(:parse).with('property = madsrdf:identifiesRWO/madsrdf:birthDate/schema:label ;').and_return(basic_program)
+      allow(Ldpath::Program).to receive(:parse).with('property = skos:prefLabel ::xsd:string ;').and_return(expanded_label_program)
+      allow(Ldpath::Program).to receive(:parse).with('property = loc:lccn ::xsd:string ;').and_return(expanded_id_program)
+      allow(basic_program).to receive(:evaluate).with(subject_uri, graph).and_return('property' => [expanded_uri])
+      allow(expanded_label_program).to receive(:evaluate).with(RDF::URI.new(subject_uri), graph).and_return('property' => [expanded_label])
+      allow(expanded_id_program).to receive(:evaluate).with(RDF::URI.new(subject_uri), graph).and_return('property' => [expanded_id])
+    end
+    it 'returns the uri, id, label for the expanded uri value' do
+      expanded_values = subject.expanded_values(graph, subject_uri).first
+      expect(expanded_values).to be_kind_of Hash
+      expect(expanded_values[:uri]).to eq expanded_uri
+      expect(expanded_values[:id]).to eq expanded_id
+      expect(expanded_values[:label]).to eq expanded_label
+    end
+  end
+end