krikri 0.12.3 → 0.12.4

data/spec/ldp/nr_source_spec.rb~

@@ -0,0 +1,3 @@
+require 'spec_helper'
+
+describe Krikri::LDP::Resource do

data/spec/ldp/rdf_source_spec.rb~

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Krikri::LDP::RdfSource do
+end

data/spec/ldp/resource_spec.rb~

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Krikri::LDP::Resource do
+  before do 
+    class DummyResource; include Krikri::LDP::Resource; end
+    subject.connection_uri = 'http://localhost:8080/marmotta/ldp'
+  end
+
+  subject { DummyResource.new }
+  let(:base_uri) { 'http://localhost:8080/marmotta/ldp/container' }
+  let(:slug) { 'moomin' }
+
+  it 'has a connection' do
+    expect(subject.ldp_connection).to be_a Faraday::Connection
+    require 'pry'
+    binding.pry
+  end
+  
+  describe '#create' do
+    it 'creates ldp resources' do
+      require 'pry'
+      binding.pry
+      expect { subject.create(base_uri, nil) }.not_to raise_error
+    end
+
+    it 'accepts slug' do
+      expect(subject.create(base_uri, nil, :Slug => slug)
+               .env['response_headers']['location'])
+        .to eq 'http://localhost:8080/marmotta/ldp/container/moomin'
+    end
+  end
+
+  describe '#save' do
+    it 'is idempotent' do
+      first = subject.save(base_uri, nil, :Slug => slug)
+      second = subject.save(base_uri, nil, :Slug => slug)
+
+      expect(first.env['response_headers']['location'])
+        .to eq second.env['response_headers']['location']
+    end
+  end
+
+  describe '#exists?' do
+    it "knows it doesn't exist" do
+      expect(subject).not_to exist
+    end
+  end
+  
+end

data/spec/lib/krikri/enrichment_agent_spec.rb~

@@ -0,0 +1,4 @@
+describe Krikri::Enrichment::Agent do
+  opts = {}
+  it_behaves_like 'a software agent', opts
+end

data/spec/lib/krikri/enrichments/language_to_lexvo_spec.rb

@@ -142,6 +142,11 @@ describe Krikri::Enrichments::LanguageToLexvo do
       expect(subject.match_iso('eng').rdf_subject)
         .to eq english
     end
+
+    it 'finds 3 letter ISO codes case insensitively' do
+      expect(subject.match_iso('Eng').rdf_subject)
+        .to eq english
+    end
   end
 
   describe '#match_label' do

data/spec/lib/krikri/enrichments/split_on_provided_label_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Krikri::Enrichments::SplitOnProvidedLabel do
+  it_behaves_like 'a field enrichment'
+
+  describe '#enrich_value' do
+    let(:resource) { DPLA::MAP::Agent.new }
+
+    it 'skips non-resource values' do
+      date = Date.today
+      expect(subject.enrich_value(date)).to eq date
+    end
+
+    it 'skips values that do not respond to providedLabel' do
+      resource = ActiveTriples::Resource.new
+      expect(subject.enrich_value(resource)).to eq resource
+    end
+
+    it 'leaves an existing single providedLabel as is' do
+      resource.providedLabel = 'moomin'
+      expect(subject.enrich_value(resource)).to eq resource
+    end
+
+    it 'leaves existing non-providedLabel values in place' do
+      close_match = 'Moomin'
+
+      resource.providedLabel = ['moomin', 'moominmama']
+      resource.closeMatch    = close_match
+
+      expect(subject.enrich_value(resource).map(&:closeMatch))
+        .to contain_exactly([close_match], [])
+    end
+
+    it 'splits multiple provided ' do
+      labels                 = ['moomin', 'moominmama']
+      resource.providedLabel = labels
+
+      expect(subject.enrich_value(resource).map(&:providedLabel))
+        .to contain_exactly([labels.first], [labels.last])
+    end
+  end
+end

data/spec/lib/krikri/harvesters/api_harvester_spec.rb~

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe Krikri::Harvesters::ApiHarvester do
+  it_behaves_like 'a harvester'
+
+  let(:args) { { uri: 'http://example.org/endpoint' } }
+  subject { described_class.new(args) }
+
+  shared_context 'with responses' do
+    let(:query_opts) { { :q => 'tags_ssim:dpla' } }
+    let(:response_string) do
+      <<EOM
+{ "response": {
+    "numFound": 467354,
+    "start": 0,
+    "docs": []
+  }
+}
+EOM
+    end
+
+    before do
+      allow(RestClient).to recieve(:get).with(args[:uri], query_opts)
+                            .and_return(response_string)
+    end
+  end
+
+  describe '#new' do
+    it 'accepts api parameters' do
+      described_class.new()
+      require 'pry'
+      binding.pry
+    end
+  end
+
+  describe '.expected_opts' do
+    it 'returns a hash with key and options' do
+    end
+  end
+
+  describe '#count' do
+    it 'returns a count' do
+      expect(subject.count).to eq 100
+    end
+  end
+end

data/spec/lib/krikri/harvesters/basic_save_behavior_spec.rb~

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Krikri::Harvesters::BasicSaveBehavior do
+  it_behaves_like 'a harvest behavior'
+
+  subject { described_class.new(record, activity_uri) }
+
+
+  describe '#process_record' do
+    it ''
+  end
+end

data/spec/lib/krikri/harvesters/file_harvester_spec.rb~

@@ -0,0 +1,3 @@
+require 'spec_helper'
+
+describe Krikri::Harvesters::FileHarvester do

data/spec/lib/krikri/harvesters/harvest_behavior_spec.rb~

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Krikri::Harvesters::HarvestBehavior do
+  it_behaves_like 'a harvest behavior'
+end

data/spec/lib/krikri/harvesters/mdl_api_harvester_spec.rb~

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe Krikri::Harvesters::MdlApiHarvester do
+  it_behaves_like 'a harvester'
+
+  let(:args) { { uri: 'http://example.org/endpoint' } }
+  subject { described_class.new(args) }
+
+
+end

data/spec/lib/krikri/harvesters/mdl_harvester_spec.rb~

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Krikri::Harvesters::MdlHarvester do
+  let(:args) { { uri: 'http://example.org/endpoint', api: query_opts } }
+  let(:query_opts) { {} }
+  subject { described_class.new(args) }
+
+end

data/spec/lib/krikri/harvesters/oai_skip_deleted_behavior.rb~

@@ -0,0 +1,7 @@
+module Krikri::Harvesters
+  class BasicSaveBehavior < HarvestBehavior
+    def process_record
+      record.save(activity_uri)
+    end
+  end
+end

data/spec/lib/krikri/harvesters/oai_skip_deleted_behavior_spec.rb~

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Krikri::Harvesters::OAISkipDeletedBehavior do
+  it_behaves_like 'a harvest behavior'
+
+  subject { described_class.new(record, activity_uri) }
+  let(:record) { double('record') }
+  let(:activity_uri) { double('activity URI') }
+
+  describe '#process_record' do
+    it 'calls save when record is not deleted' do
+      expect(record).to receive(:save).with(activity_uri)
+    end
+  end
+end

data/spec/lib/krikri/id_service_spec.rb~

@@ -0,0 +1,3 @@
+require 'spec_helper'
+
+describe Krikri::IdService do

data/spec/lib/krikri/job_spec.rb~

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Krikri::Job do
+  describe '.perform' do
+    it 'calls run on activity by id' do
+      activity_id = 1
+      activity = double('activity')
+    end
+  end
+
+  describe '.run' do
+  end
+end

data/spec/lib/krikri/map_crosswalk_spec.rb

@@ -71,6 +71,21 @@ describe Krikri::MapCrosswalk::CrosswalkHashBuilder do
         end
       end
 
+      context 'with description' do
+        before do
+          aggregation.sourceResource.first.description = [desc, desc2]
+          subject.build
+        end
+
+        let(:desc) { 'Window of the Stonewall Bar N.Y. 1969.' }
+        let(:desc2) { 'A nice description' }
+
+        it 'has crosswalked multiple descriptions' do
+          expect(subject.hash[:sourceResource][:description])
+            .to contain_exactly(desc, desc2)
+        end
+      end
+
       context 'with place' do
         before do
           aggregation.sourceResource.first.spatial.first.label = label

data/spec/lib/krikri/map_crosswalk_spec.rb~

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Krikri::MapCrosswalk do
+  subject { DPLA::MapAggregation }
+end

data/spec/lib/krikri/mapper_agent_spec.rb~

@@ -0,0 +1,64 @@
+describe Krikri::Mapper::Agent do
+  opts = { name: :agent_map, generator_uri: 'http://example.org/agent/gen/1' }
+  it_behaves_like 'a software agent', opts, Krikri::MappingJob
+
+  subject { described_class.new(opts) }
+
+  let(:generator_uri) { 'http://example.org/agent/gen/1' }
+  let(:activity_uri) { 'http://example.org/agent/act/1' }
+  let(:mapping_name) { :agent_map }
+  let(:opts) { { name: mapping_name, generator_uri: generator_uri } }
+
+  describe '#run' do
+    let(:record_double) { double(DPLA::MAP::Aggregation) }
+    let(:records) do
+      [record_double, record_double.clone, record_double.clone]
+    end
+
+    before do
+      allow(subject).to receive(:records).and_return([:record1, :record2])
+      allow(record_double).to receive(:set_subject!)
+      allow(record_double).to receive(:save)
+      expect(Krikri::Mapper).to receive(:map).with(mapping_name, subject.records)
+        .and_return(records)
+    end
+
+    it 'calls mapper' do
+      subject.run
+    end
+
+    it 'sets generator' do
+      records.each do |rec|
+        statement = double
+        allow(RDF).to receive(:Statement)
+          .with(rec, RDF::PROV.wasGeneratedBy, activity_uri)
+          .and_return(statement)
+        expect(rec).to receive(:<<).with(statement)
+      end
+      subject.run(activity_uri)
+    end
+  end
+
+  # TODO: these tests are tied closely to implementation.
+  #       This is a code smell. Consider refactor of ProvenanceQueryClient
+  #       and #records.
+  describe '#records' do
+    let(:solutions) { double(RDF::Query::Solutions) }
+    let(:solution) { double(RDF::Query::Solutions) }
+    let(:record_double) { double(Krikri::OriginalRecord) }
+
+    it 'returns a lazy enum' do
+      expect(subject.records).to be_a Enumerator::Lazy
+    end
+
+    it 'gets records for generated by harvest_activity' do
+      expect_any_instance_of(Krikri::ProvenanceQueryClient)
+        .to receive(:find_by_activity).with(generator_uri).and_return(solutions)
+      expect(solutions).to receive(:lazy).and_return([solution])
+      expect(solution).to receive(:record).and_return(:uri)
+      expect(OriginalRecord).to receive(:load).with(:uri.to_s)
+        .and_return(:record)
+      expect(subject.records).to eq [:record]
+    end
+  end
+end

data/spec/lib/krikri/mapper_spec.rb~

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Krikri::Mapper do
+
+end

data/spec/lib/krikri/mapping_dsl/parser_methods_spec.rb~

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Krikri::MappingDSL::ParserMethods do
+  before do
+    # dummy class
+    class DummyParserImpl
+      include Krikri::MappingDSL::ParserMethods
+    end
+  end
+
+  after do
+    Object.send(:remove_const, 'DummyParserImpl')
+  end
+
+  subject { DummyParserImpl.new }
+
+  it 'raises an error without parser' do
+    expect { subject.record }
+      .to raise_error 'No parser selected; set a parser with #parser(class)'
+  end
+
+  context 'with parser' do
+    before do
+      subject.parser parser
+      allow_any_instance_of(parser).to receive(:root).and_return()
+    end
+
+    let(:parser) { class_double("Krikri::XmlParser") }
+
+    describe '#record' do
+      it 'returns a parsed value instance' do
+        expect(subject.record)
+          .to be_a Krikri::MappingDSL::ParserMethods::ParsedValue
+      end
+
+      it 'initializes parsed value with args and parser' do
+        expect(Krikri::MappingDSL::ParserMethods::ParsedValue).to receive(:new)
+          .with(parser, :arg_1, :arg_2, :arg_3)
+        subject.record(:arg_1, :arg_2, :arg_3)
+      end
+    end
+  end
+end
+
+describe Krikri::MappingDSL::ParserMethods::ParsedValue do
+  subject { described_class.new(parser) }
+  let(:record) { double() }
+  let(:parser) { class_double("Krikri::XmlParser") }
+  let(:root) { instance_double("Krikri::XmlParser") }
+  let(:value) { instance_double("Krikri::XmlParser::Value") }
+
+  describe '#to_proc' do
+    # before do
+    #   expect(parser).to receive(:new).with(record).and_return(:value)
+    # end
+
+    it 'resolves to a parser root' do
+      expect(parser).to receive(:new).with(record).and_return(root)
+      expect(root).to receive(:root).and_return(value)
+      expect(value).to receive(values).and_return(:my_value)
+      require 'pry'
+      binding.pry
+    end
+  end
+end

data/spec/lib/krikri/mapping_dsl/property_declaration_spec.rb~

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Krikri::MappingDSL::PropertyDeclaration do
+  it_behaves_like 'a named property'
+  it_behaves_like 'a valued property'
+
+  subject { described_class.new(:my_property, value) }
+
+  describe '#to_proc' do
+    shared_context 'mapped property' do
+      before do
+        expect(mapped).to receive(:my_property=).with(value)
+      end
+      let(:mapped) { double }
+    end
+
+    shared_context 'property block' do
+      subject do
+        described_class.new(:my_property, start_value) do |v|
+          v.upcase
+        end
+      end
+      let(:start_value) do
+        return value.map(&:downcase) if value.is_a? Enumerable
+        value.downcase
+      end
+    end
+
+    shared_examples 'a property value' do
+      it 'gives a proc that sets value' do
+        subject.to_proc.call(mapped, '')
+      end
+    end
+
+    context 'static' do
+      include_context 'mapped property'
+      it_behaves_like 'a property value'
+    end
+
+    context 'with multiple values' do
+      include_context 'mapped property'
+      it_behaves_like 'a property value'
+
+      let(:value) { %w('value_1', 'value_2') }
+
+      context 'with block of arity 1' do
+        include_context 'property block'
+        it_behaves_like 'a property value'
+
+        let(:value) { %w('value_1', 'value_2').map(&:upcase) }
+      end
+    end
+
+    context 'with block of arity 1' do
+      include_context 'mapped property'
+      include_context 'property block'
+      it_behaves_like 'a property value'
+
+      let(:value) { 'value'.upcase }
+    end
+
+    context 'with callable value' do
+      include_context 'mapped property'
+      it_behaves_like 'a property value'
+
+      before do
+        expect(proc_value).to receive(:call).and_return(value)
+      end
+
+      subject { described_class.new(:my_property, proc_value) }
+
+      let(:proc_value) { ->(_) {} }
+    end
+
+    context 'with block of wrong arity' do
+      subject do
+        described_class.new(:my_property, value) { |v, what| v + what }
+      end
+
+      it 'raises error' do
+        expect { subject.to_proc.call(nil, nil) }
+          .to raise_error('Block must have arity of 1 to be applied to '\
+                          'property')
+      end
+    end
+  end
+end