rof 1.0.7 → 1.2.0

data/spec/lib/rof/filter_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+module ROF
+  RSpec.describe Filter do
+    subject { described_class.new }
+    it 'defines an abstract #process method' do
+      expect { subject.process({}) }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/lib/rof/filters/bendo_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'rof/filters/bendo'
+require 'support/an_rof_filter'
+
+RSpec.describe ROF::Filters::Bendo do
+  it_behaves_like "an ROF::Filter"
+  let(:bendo){ nil }
+  let(:valid_options) { { bendo_info: bendo} }
+
+  it 'requires bendo_info to initialize' do
+    expect { described_class.new({}) }.to raise_error(KeyError)
+  end
+  describe '#process' do
+    subject { described_class.new(bendo_info: bendo).process(original_object_list) }
+    let(:original_object_list) do
+      [
+        { "content-meta" => { "URL" => "bendo:/item/12345/a/file.txt" } },
+        { "not_gonna_change" => { "URL" => "bendo:/item/12345/a/file.txt" } },
+        { "content-meta" => { "URL" => "somewhere:/item/12345/a/file.txt" } }
+      ]
+    end
+
+    context 'if bendo is set' do
+      let(:bendo) { 'http://bendo.host' }
+      it 'will replace "bendo:" with the given bendo string' do
+        expected_object_list = [
+          { "content-meta" => { "URL" => "#{bendo}/item/12345/a/file.txt" } },
+          { "not_gonna_change" => { "URL" => "bendo:/item/12345/a/file.txt" } },
+          { "content-meta" => { "URL" => "somewhere:/item/12345/a/file.txt" } }
+        ]
+        expect(subject).to eq(expected_object_list)
+      end
+    end
+
+    context 'if bendo is not set' do
+      let(:bendo) { nil }
+      it 'will not replace "bendo:" in any of the data entries' do
+        expect(subject).to eq(original_object_list)
+      end
+    end
+  end
+end

data/spec/lib/rof/filters/date_stamp_spec.rb

@@ -1,19 +1,23 @@
 require 'spec_helper'
+require 'support/an_rof_filter'
 
 module ROF
   module Filters
     describe DateStamp do
+      it_behaves_like "an ROF::Filter"
+      let(:valid_options) { {} }
+
       before(:all) do
         @today = Date.new(2015, 1, 23)
         @today_s = "2015-01-23Z"
-        @w = DateStamp.new(@today)
+        @w = DateStamp.new(as_of: @today)
       end
 
       it "it adds a metadata section if needed" do
         items = [{
           "type" => "ABC"
         }]
-        after = @w.process(items, '')
+        after = @w.process(items)
         expect(after.length).to eq(1)
         expect(after.first).to eq({
           "type" => "ABC",
@@ -32,7 +36,7 @@ module ROF
             "dc:title" => "something"
           }
         }]
-        after = @w.process(items, '')
+        after = @w.process(items)
         expect(after.length).to eq(1)
         expect(after.first).to eq({
           "type" => "BCD",
@@ -52,7 +56,7 @@ module ROF
             "dc:dateSubmitted" => "any date"
           }
         }]
-        after = @w.process(items, '')
+        after = @w.process(items)
         expect(after.length).to eq(1)
         expect(after.first).to eq({
           "type" => "CDE",
@@ -73,7 +77,7 @@ module ROF
             "dc:modified" => "any date"
           }
         }]
-        after = @w.process(items, '')
+        after = @w.process(items)
         expect(after.length).to eq(1)
         expect(after.first).to eq({
           "type" => "CDE",

data/spec/lib/rof/filters/file_to_url_spec.rb

@@ -1,8 +1,12 @@
 require 'spec_helper'
+require 'support/an_rof_filter'
 
 module ROF
   module Filters
     describe FileToUrl do
+      it_behaves_like "an ROF::Filter"
+      let(:valid_options) { {} }
+
       before(:all) do
         @w = FileToUrl.new
       end
@@ -11,7 +15,7 @@ module ROF
         items = [{
           "type" => "ABC"
         }]
-        after = @w.process(items, '')
+        after = @w.process(items)
         expect(after.length).to eq(1)
         expect(after.first).to eq({
           "type" => "ABC"
@@ -27,7 +31,7 @@ module ROF
           "bendo-item" => "12345",
           "thumbnail-content" => "a_file.png"
         }]
-        after = @w.process(items, '')
+        after = @w.process(items)
         expect(after.length).to eq(2)
         expect(after.first).to eq({
           "type" => "ABC",
@@ -49,7 +53,7 @@ module ROF
         "content-meta" => {
           "mime-type" => "image/png"
         }}]
-        after = @w.process(items, '')
+        after = @w.process(items)
         expect(after.length).to eq(2)
         expect(after.first).to eq({
           "bendo-item" => "12345",

data/spec/lib/rof/filters/label_spec.rb

@@ -1,93 +1,137 @@
 require 'spec_helper'
+require 'support/an_rof_filter'
 
 module ROF
   module Filters
-    describe Label do
+    RSpec.describe Label do
+      it_behaves_like "an ROF::Filter"
+      let(:valid_options) { { id_list: ids } }
       let(:ids) { ["101", "102", "103", "104", "105"] }
-      before(:each) {
-        @labeler = Label.new(nil, id_list: ids)
-      }
-      it "ignores non-fojects" do
-        list = [{"type" => "not fobject"}]
-        expect(@labeler.process(list, '')).to eq([{"type" => "not fobject"}])
-      end
-      it "skips already assigned ids" do
-        list = [{"type" => "fobject", "pid" => "123"}]
-        expect(@labeler.process(list, '')).to eq([{"type" => "fobject", "pid" => "123", "bendo-item" => "123"}])
-      end
-      it "assignes missing pids" do
-        list = [{"type" => "fobject"}]
-        expect(@labeler.process(list, '')).to eq([{"type" => "fobject", "pid" => "101", "bendo-item" => "101"}])
-      end
-      it "assignes pids which are labels" do
-        list = [{"type" => "fobject", "pid" => "$(zzz)"}]
-        expect(@labeler.process(list, '')).to eq([{"type" => "fobject", "pid" => "101", "bendo-item" => "101"}])
-      end
-      it "resolves loops" do
-        list = [{"type" => "fobject",
-                 "pid" => "$(zzz)",
-                 "rels-ext" => {
-                    "partOf" => ["123", "$(zzz)"]
-                 }}]
-        expect(@labeler.process(list, '')).to eq([{"type" => "fobject",
-                                               "pid" => "101",
-                                               "bendo-item"=>"101",
-                                               "rels-ext" => {
-                                                  "partOf" => ["123", "101"]}}])
+
+      context 'initialization options' do
+        it 'can be initialized with a list of IDs' do
+          expect { Label.new(valid_options) }.not_to raise_error
+        end
+        it 'can be initialized with a noid_server and pool_name' do
+          noid_server = double
+          pool_name = double
+          expect(described_class::NoidsPool).to receive(:new).with(noid_server, pool_name)
+          expect { Label.new(noid_server: noid_server, pool_name: pool_name) }.not_to raise_error
+        end
+        it 'will fail if not given a list of IDs nor a noid_server' do
+          expect { Label.new }.to raise_error(described_class::NoPool)
+        end
       end
-      it "handles multiple items" do
-        list = [{"type" => "fobject",
-                 "pid" => "$(zzz)",
+
+      describe '#process' do
+        before(:each) {
+          @labeler = Label.new(id_list: ids)
+        }
+
+        it "ignores non-fojects" do
+          list = [{"type" => "not fobject"}]
+          expect(@labeler.process(list)).to eq([{"type" => "not fobject"}])
+        end
+        it "skips already assigned ids" do
+          list = [{"type" => "fobject", "pid" => "123"}]
+          expect(@labeler.process(list)).to eq([{"type" => "fobject", "pid" => "123", "bendo-item" => "123"}])
+        end
+        it "assignes missing pids" do
+          list = [{"type" => "fobject"}]
+          expect(@labeler.process(list)).to eq([{"type" => "fobject", "pid" => "101", "bendo-item" => "101"}])
+        end
+        it "assignes pids which are labels" do
+          list = [{"type" => "fobject", "pid" => "$(zzz)"}]
+          expect(@labeler.process(list)).to eq([{"type" => "fobject", "pid" => "101", "bendo-item" => "101"}])
+        end
+        it "resolves loops" do
+          list = [{"type" => "fobject",
+                   "pid" => "$(zzz)",
+                   "rels-ext" => {
+                      "partOf" => ["123", "$(zzz)"]
+                   }}]
+          expect(@labeler.process(list)).to eq([{"type" => "fobject",
+                                                 "pid" => "101",
+                                                 "bendo-item"=>"101",
+                                                 "rels-ext" => {
+                                                    "partOf" => ["123", "101"]}}])
+        end
+        it "handles multiple items" do
+          list = [{"type" => "fobject",
+                   "pid" => "$(zzz)",
+                   "rels-ext" => {
+                      "partOf" => ["123", "$(zzz)"]
+                   }},
+                  {"type" => "fobject",
+                   "rels-ext" => { "memberOf" => ["$(zzz)"]}}]
+          expect(@labeler.process(list)).to eq([
+                {"type" => "fobject",
+                 "pid" => "101",
+                 "bendo-item" => "101",
                  "rels-ext" => {
-                    "partOf" => ["123", "$(zzz)"]
+                   "partOf" => ["123", "101"]
                  }},
                 {"type" => "fobject",
-                 "rels-ext" => { "memberOf" => ["$(zzz)"]}}]
-        expect(@labeler.process(list, '')).to eq([
-              {"type" => "fobject",
-               "pid" => "101",
-               "bendo-item" => "101",
-               "rels-ext" => {
-                 "partOf" => ["123", "101"]
-               }},
-              {"type" => "fobject",
-               "pid" => "102",
-               "bendo-item" => "101",
-               "rels-ext" => {
-                 "memberOf" => ["101"]
-               }}
-              ])
-      end
-      it "errors on undefined labels" do
-        list = [{"type" => "fobject",
+                 "pid" => "102",
+                 "bendo-item" => "101",
                  "rels-ext" => {
-                    "partOf" => ["123", "$(zzz)"]
-                 }}]
-        expect { @labeler.process(list, '') }.to raise_error(Label::MissingLabel)
-      end
+                   "memberOf" => ["101"]
+                 }}
+                ])
+        end
+        it "errors on undefined labels" do
+          list = [{"type" => "fobject",
+                   "rels-ext" => {
+                      "partOf" => ["123", "$(zzz)"]
+                   }}]
+          expect { @labeler.process(list) }.to raise_error(Label::MissingLabel)
+        end
 
-      it "replaces labels in arrays" do
-        list = ["a", "something $(b) and $(a)", "$(not a label)"]
-        labels = {"a" => "abc", "b" => "qwe"}
-        expect(@labeler.replace_labels(list, labels, false)).to eq(["a", "something qwe and abc", "$(not a label)"])
+        it "replaces labels in arrays" do
+          list = ["a", "something $(b) and $(a)", "$(not a label)"]
+          labels = {"a" => "abc", "b" => "qwe"}
+          expect(@labeler.replace_labels(list, labels, false)).to eq(["a", "something qwe and abc", "$(not a label)"])
 
-        hash = {"$(a)" => "this should $(b)", sym: :symbol, b: {b: "$(a) $(z)"}}
-        expect(@labeler.replace_labels(hash, labels, false)).to eq({
-          "$(a)" => "this should qwe",
-          sym: :symbol,
-          b: {b: "abc $(z)"}
-        })
-      end
+          hash = {"$(a)" => "this should $(b)", sym: :symbol, b: {b: "$(a) $(z)"}}
+          expect(@labeler.replace_labels(hash, labels, false)).to eq({
+            "$(a)" => "this should qwe",
+            sym: :symbol,
+            b: {b: "abc $(z)"}
+          })
+        end
 
-      it "handles pids in isMemberOf" do
-        list = [
-          {"type" => "fobject", "pid" => "$(zzz)"},
-          {"type" => "fobject", "rels-ext" => { "isMemberOfCollection" => ["$(zzz)"]}}
-        ]
-        expect(@labeler.process(list, '')).to eq([
-          {"type" => "fobject", "pid" => "101", "bendo-item" =>"101"},
-          {"type" => "fobject", "pid" => "102", "bendo-item" =>"101", "rels-ext" => { "isMemberOfCollection" => ["101"]}}
-        ])
+        it "handles pids in isMemberOf" do
+          list = [
+            {"type" => "fobject", "pid" => "$(zzz)"},
+            {"type" => "fobject", "rels-ext" => { "isMemberOfCollection" => ["$(zzz)"]}}
+          ]
+          expect(@labeler.process(list)).to eq([
+            {"type" => "fobject", "pid" => "101", "bendo-item" =>"101"},
+            {"type" => "fobject", "pid" => "102", "bendo-item" =>"101", "rels-ext" => { "isMemberOfCollection" => ["101"]}}
+          ])
+        end
+      end
+    end
+    RSpec.describe Label::NoidsPool do
+      let(:noids_server_url) { 'https://noids.library.nd.edu' }
+      let(:pool_name) { 'rof' }
+      let(:inner_pool) { double(mint: [double], closed?: double) }
+      let(:connection) { double('Noids Conneciton', get_pool: inner_pool) }
+      before do
+        expect(NoidsClient::Connection).to receive(:new).with(noids_server_url).and_return(connection)
+        expect(connection).to receive(:get_pool).with(pool_name).and_return(inner_pool)
+      end
+      describe '#shift' do
+        subject { described_class.new(noids_server_url, pool_name).shift }
+        it "returns the first value of the inner pool's #mint method" do
+          expect(subject).to eq(inner_pool.mint.first)
+        end
+      end
+      describe '#empty?' do
+        subject { described_class.new(noids_server_url, pool_name).empty? }
+        it 'returns whether the inner pool is closed' do
+          expect(subject).to eq(inner_pool.closed?)
+        end
       end
     end
   end

data/spec/lib/rof/filters/work_spec.rb

@@ -1,10 +1,13 @@
 require 'spec_helper'
+require 'support/an_rof_filter'
 
 module ROF
   module Filters
     describe Work do
+      it_behaves_like "an ROF::Filter"
+      let(:valid_options) { { file_name: '' } }
       it "handles variant work types" do
-        w = Work.new
+        w = Work.new(valid_options)
 
         item = {"type" => "Work", "owner" => "user1"}
         after = w.process_one_work(item)
@@ -32,7 +35,7 @@ module ROF
       end
 
       it "makes the first file be the representative" do
-        w = Work.new
+        w = Work.new(valid_options)
 
         item = {"type" => "Work", "owner" => "user1", "files" => ["a.txt", "b.jpeg"]}
         after = w.process_one_work(item)
@@ -50,7 +53,7 @@ module ROF
       end
 
       it "decodes files correctly" do
-        w = Work.new
+        w = Work.new(valid_options)
 
         item = {
           "type" => "Work",
@@ -72,7 +75,7 @@ module ROF
         expect(after.length).to eq(3)
         expect(after[0]).to include("type" => "fobject",
                                     "af-model" => "GenericWork",
-				    "rels-ext" => {}, 
+				    "rels-ext" => {},
                                     "pid" => "$(pid--0)")
         expect(after[1]).to include("type" => "fobject",
                                     "af-model" => "GenericFile",

data/spec/lib/rof/filters_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module ROF
+  RSpec.describe Filters do
+    describe '.for' do
+      it 'raises an exception when one is not registered' do
+        expect { described_class.for('obviously-not-valid') }.to raise_error(described_class::UnknownFilterError)
+      end
+      it 'instantiates a valid filter' do
+        expect(described_class.for('datestamp')).to be_a(ROF::Filters::DateStamp)
+      end
+    end
+  end
+end

data/spec/lib/rof/translator_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'rof/translator'
+
+module ROF
+  RSpec.describe Translator do
+    let(:input) { double }
+    let(:config) { double }
+    describe '.call' do
+      subject { described_class.call(input, config) }
+      it 'is an abstract method' do
+        expect { subject }.to raise_error(NotImplementedError)
+      end
+    end
+  end
+end

data/spec/lib/rof/{translate_csv_spec.rb → translators/csv_to_rof_spec.rb}

@@ -1,30 +1,30 @@
 require 'spec_helper'
 
-module ROF
+module ROF::Translators
   describe "translate CSV" do
     it "requires the columns type and owner" do
       s = "dc:title,access,owner"
-      expect{TranslateCSV.run(s)}.to raise_error(ROF::TranslateCSV::MissingOwnerOrType)
+      expect{CsvToRof.call(s)}.to raise_error(ROF::Translators::CsvToRof::MissingOwnerOrType)
 
       s = "dc:title,access,type"
-      expect{TranslateCSV.run(s)}.to raise_error(ROF::TranslateCSV::MissingOwnerOrType)
+      expect{CsvToRof.call(s)}.to raise_error(ROF::Translators::CsvToRof::MissingOwnerOrType)
 
       s = "dc:title,type,owner,access"
-      expect(TranslateCSV.run(s)).to eq([])
+      expect(CsvToRof.call(s)).to eq([])
     end
 
     it "requires rows to have an owner and type" do
       s = %q{type,owner
       Work,
       }
-      expect{TranslateCSV.run(s)}.to raise_error(ROF::TranslateCSV::MissingOwnerOrType)
+      expect{CsvToRof.call(s)}.to raise_error(ROF::Translators::CsvToRof::MissingOwnerOrType)
     end
 
     it "deocdes the access field into rights" do
       s = %q{type,owner,access
       Work,user1,"private;edit=user2,user3"
       }
-      rof = TranslateCSV.run(s)
+      rof = CsvToRof.call(s)
       expect(rof).to eq([{"type" => "Work", "owner" => "user1", "rights" => {"edit" => ["user1", "user2", "user3"]}}])
     end
 
@@ -32,13 +32,13 @@ module ROF
       s = %q{type,owner,dc:title,foaf:name
       Work,user1,"Q, A Letter",Jane Smith|Zander
       }
-      rof = TranslateCSV.run(s)
+      rof = CsvToRof.call(s)
       expect(rof).to eq([{
         "type" => "Work",
         "owner" => "user1",
         "rights" => {"edit" => ["user1"]},
         "metadata" => {
-          "@context" => RdfContext,
+          "@context" => ROF::RdfContext,
           "dc:title" => "Q, A Letter",
           "foaf:name" => ["Jane Smith", "Zander"]}
       }])
@@ -48,7 +48,7 @@ module ROF
       s = %q{type,owner,curate_id
       Work,user1,abcdefg
       }
-      rof = TranslateCSV.run(s)
+      rof = CsvToRof.call(s)
       expect(rof).to eq([{
         "type" => "Work",
         "owner" => "user1",
@@ -61,13 +61,13 @@ module ROF
       s = %q{type,owner,dc:title,foaf:name
       Work,user1,"Q, A Letter",Jane Smith | Zander
       }
-      rof = TranslateCSV.run(s)
+      rof = CsvToRof.call(s)
       expect(rof).to eq([{
         "type" => "Work",
         "owner" => "user1",
         "rights" => {"edit" => ["user1"]},
         "metadata" => {
-          "@context" => RdfContext,
+          "@context" => ROF::RdfContext,
           "dc:title" => "Q, A Letter",
           "foaf:name" => ["Jane Smith", "Zander"]}
       }])
@@ -78,13 +78,13 @@ module ROF
       Work,user1,"Q, A Letter",thumb
       +,user1,,extra file.txt
       }
-      rof = TranslateCSV.run(s)
+      rof = CsvToRof.call(s)
       expect(rof).to eq([{
         "type" => "Work",
         "owner" => "user1",
         "rights" => {"edit" => ["user1"]},
         "metadata" => {
-          "@context" => RdfContext,
+          "@context" => ROF::RdfContext,
           "dc:title" => "Q, A Letter"},
         "files" => [
           "thumb",
@@ -101,7 +101,7 @@ module ROF
       s = %q{type,owner,dc:title,files
       +,user1,,extra file.txt
       }
-      expect {TranslateCSV.run(s)}.to raise_error(ROF::TranslateCSV::NoPriorWork)
+      expect {CsvToRof.call(s)}.to raise_error(ROF::Translators::CsvToRof::NoPriorWork)
     end