krikri 0.2.1 → 0.3.1

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,25 @@
+require 'spec_helper'
+
+describe Krikri::Harvesters::OAISkipDeletedBehavior do
+  it_behaves_like 'a harvest behavior'
+
+  subject { described_class.new(record, activity_uri) }
+  let(:record) { build(:oai_dc_record) }
+  let(:activity_uri) { double('activity URI') }
+
+  describe '#process_record' do
+    context 'with deleted record' do
+      let(:record) { build(:oai_deleted_record) }
+
+      it 'skips record' do
+        expect(record).not_to receive(:save)
+        subject.process_record
+      end
+    end
+
+    it 'saves record' do
+      expect(record).to receive(:save).with(activity_uri)
+      subject.process_record
+    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/index_service_spec.rb

@@ -1,14 +1,28 @@
 require 'spec_helper'
 
 describe Krikri::IndexService do
-
-  subject { Krikri::IndexService }
   let(:solr) { RSolr.connect }
 
-  describe '#solr_doc' do
+  describe '#initialize' do
+    context 'with args' do
+      subject { described_class.new(opts) }
+      let(:opts) { { url: 'http://my-client-uri/' } }
 
-    context 'without models' do
+      it 'passes options to RSolr client' do
+        expect(subject.solr.uri.to_s).to eq opts[:url]
+      end
+    end
 
+    it 'defaults to Krikri::Settings.solr' do
+      uri = 'http://moomin.org/'
+      allow(Krikri::Settings)
+        .to receive(:solr).and_return(url: uri)
+      expect(subject.solr.uri.to_s).to eq uri
+    end
+  end
+
+  describe '#solr_doc' do
+    context 'without models' do
       before :each do
         fake_schema_keys = ['a', 'b', 'c', 'b_c', 'b_d']
         allow(subject).to receive(:schema_keys).and_return(fake_schema_keys)
@@ -17,8 +31,7 @@ describe Krikri::IndexService do
       it 'converts JSON into Solr-compatible hash' do
         json = { 'a' => '1', 'b' => { 'c' => '2', 'd' => '3' } }.to_json
         flat_hash = { 'a' => '1', 'b_c' => '2', 'b_d' => '3' }
-        result = subject.class_eval { solr_doc(json) }
-        expect(result).to eq flat_hash
+        expect(subject.solr_doc(json)).to eq flat_hash
       end
 
       it 'removes special character strings from keys' do
@@ -28,15 +41,13 @@ describe Krikri::IndexService do
           '@c' => '3'
         }.to_json
         flat_hash = { 'a' => '1', 'b' => '2', 'c' => '3' }
-        result = subject.class_eval { solr_doc(json) }
-        expect(result).to eq flat_hash
+        expect(subject.solr_doc(json)).to eq flat_hash
       end
 
       it 'removes keys that are not in solr schema' do
         json = { 'a' => '1', 'invalid_key' => '0' }.to_json
         valid_hash = { 'a' => '1' }
-        result = subject.class_eval { solr_doc(json) }
-        expect(result).to eq valid_hash
+        expect(subject.solr_doc(json)).to eq valid_hash
       end
     end
 
@@ -45,14 +56,14 @@ describe Krikri::IndexService do
 
       before do
         aggregation.set_subject!('http://api.dp.la/item/123')
-        Krikri::IndexService.add aggregation.to_jsonld['@graph'][0].to_json
-        Krikri::IndexService.commit
+        subject.add aggregation.to_jsonld['@graph'][0].to_json
+        subject.commit
       end
 
       after do
         q = 'id:*'
-        Krikri::IndexService.delete_by_query(q)
-        Krikri::IndexService.commit
+        subject.delete_by_query(q)
+        subject.commit
       end
 
       it 'posts DPLA MAP JSON to solr' 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/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

@@ -6,11 +6,17 @@ describe Krikri::Mapper do
       Krikri::Mapper.define(:integration) do
         sourceResource :class => DPLA::MAP::SourceResource do
           title record.field('dc:title')
+          # test non-root methods
+          identifier header.field('xmlns:identifier')
 
           creator :class => DPLA::MAP::Agent do
             providedLabel record.field('dc:creator')
           end
         end
+
+        provider :class => DPLA::MAP::Agent, :each => header.field('xmlns:identifier'), :as => :ident do
+          providedLabel ident
+        end
       end
     end
 
@@ -18,8 +24,14 @@ describe Krikri::Mapper do
 
     it 'maps nested values' do
       mapped = Krikri::Mapper.map(:integration, record).first
+
       expect(mapped.sourceResource.first.creator.first.providedLabel)
         .to eq record.root['dc:creator'].map(&:value)
+
+      expect(mapped.sourceResource.first.identifier)
+        .to eq Array(record.header.first['xmlns:identifier'].first.value)
+      expect(mapped.provider.first.providedLabel)
+        .to eq Array(record.header.first['xmlns:identifier'].first.value)
     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

@@ -56,20 +56,13 @@ describe Krikri::MappingDSL::ParserMethods do
   end
 
   describe 'header' do
-    let(:record) { double }
+    let(:record) { double('record') }
+    let(:header) { double('header') }
 
     it 'gets the header from the record passed' do
-      allow(record).to receive(:respond_to?).with(:header)
-                        .and_return(true)
-      allow(record).to receive(:header).and_return(:header_array)
-      expect(subject.header.call(record)).to eq (:header_array)
-    end
-
-    it 'gets the header from the record passed' do
-      allow(record).to receive(:respond_to?).with(:header)
-                        .and_return(false)
-      expect { subject.header.call(record) }
-        .to raise_error "#{record} does not have a `header`"
+      allow(record).to receive(:header).and_return(header)
+      allow(header).to receive(:values).and_return(:values)
+      expect(subject.header.call(record)).to eq (:values)
     end
   end
 end
@@ -96,6 +89,14 @@ describe Krikri::MappingDSL::ParserMethods::RecordProxy do
     it 'shares a value class' do
       expect(duped.value_class).to eq subject.value_class
     end
+
+    context 'with non_root record' do
+      subject { described_class.new([], klass, true) }
+
+      it 'shares non_root status' do
+        expect(duped.non_root).to eq subject.non_root
+      end
+    end
   end
 
   describe '#call' do
@@ -105,8 +106,8 @@ describe Krikri::MappingDSL::ParserMethods::RecordProxy do
     end
 
     subject { described_class.new(call_chain, klass) }
-    let(:record) { double }
-    let(:value) { double }
+    let(:record) { double('record') }
+    let(:value) { double('value') }
 
     let(:call_chain) do
       [{ :name => :my_method,
@@ -119,6 +120,29 @@ describe Krikri::MappingDSL::ParserMethods::RecordProxy do
        }]
     end
 
+    context 'non root' do
+      before do
+        allow(record).to receive(:values).and_return([:my_value])
+      end
+
+      subject { described_class.new(call_chain, klass, true) }
+
+      it 'calls chain' do
+        call_chain.each do |spec|
+          expect(record).to receive(spec[:name]).ordered
+                             .with(*spec[:args], &spec[:block]).and_return(record)
+        end
+        subject.call(record)
+      end
+
+      it 'casts result to values' do
+        call_chain.each do |spec|
+          allow(record).to receive(spec[:name]).and_return(record)
+        end
+        expect(subject.call(record)).to eq [:my_value]
+      end
+    end
+
     it 'calls chain' do
       call_chain.each do |spec|
         expect(value).to receive(spec[:name]).ordered

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