rof 0.0.1.pre → 1.0.4

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

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+module ROF
+  module Filters
+    describe DateStamp do
+      before(:all) do
+        @today = Date.new(2015, 1, 23)
+        @today_s = "2015-01-23Z"
+        @w = DateStamp.new(@today)
+      end
+
+      it "it adds a metadata section if needed" do
+        items = [{
+          "type" => "ABC"
+        }]
+        after = @w.process(items, '')
+        expect(after.length).to eq(1)
+        expect(after.first).to eq({
+          "type" => "ABC",
+          "metadata" => {
+            "@context" => ROF::RdfContext,
+            "dc:dateSubmitted" => @today_s,
+            "dc:modified" => @today_s
+          }
+        })
+      end
+
+      it "adds a metadata relation if missing" do
+        items = [{
+          "type" => "BCD",
+          "metadata" => {
+            "dc:title" => "something"
+          }
+        }]
+        after = @w.process(items, '')
+        expect(after.length).to eq(1)
+        expect(after.first).to eq({
+          "type" => "BCD",
+          "metadata" => {
+            "dc:title" => "something",
+            "dc:dateSubmitted" => @today_s,
+            "dc:modified" => @today_s
+          }
+        })
+      end
+
+      it "doesn't mess with exsiting values" do
+        items = [{
+          "type" => "CDE",
+          "metadata" => {
+            "dc:title" => "anotherthing",
+            "dc:dateSubmitted" => "any date"
+          }
+        }]
+        after = @w.process(items, '')
+        expect(after.length).to eq(1)
+        expect(after.first).to eq({
+          "type" => "CDE",
+          "metadata" => {
+            "dc:title" => "anotherthing",
+            "dc:dateSubmitted" => "any date",
+            "dc:modified" => @today_s
+          }
+        })
+      end
+
+      it "always update the date modified" do
+        items = [{
+          "type" => "CDE",
+          "metadata" => {
+            "dc:title" => "anotherthing",
+            "dc:dateSubmitted" => "any date",
+            "dc:modified" => "any date"
+          }
+        }]
+        after = @w.process(items, '')
+        expect(after.length).to eq(1)
+        expect(after.first).to eq({
+          "type" => "CDE",
+          "metadata" => {
+            "dc:title" => "anotherthing",
+            "dc:dateSubmitted" => "any date",
+            "dc:modified" => @today_s
+          }
+        })
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+module ROF
+  module Filters
+    describe FileToUrl do
+      before(:all) do
+        @w = FileToUrl.new
+      end
+
+      it "skips rof objects which don't have bendo-items" do
+        items = [{
+          "type" => "ABC"
+        }]
+        after = @w.process(items, '')
+        expect(after.length).to eq(1)
+        expect(after.first).to eq({
+          "type" => "ABC"
+        })
+      end
+
+      it "skips rof object which don't have a content-file" do
+        items = [{
+          "type" => "ABC",
+          "bendo-item" => "12345"
+        },
+        {
+          "bendo-item" => "12345",
+          "thumbnail-content" => "a_file.png"
+        }]
+        after = @w.process(items, '')
+        expect(after.length).to eq(2)
+        expect(after.first).to eq({
+          "type" => "ABC",
+          "bendo-item" => "12345"
+        })
+        expect(after.last).to eq({
+          "bendo-item" => "12345",
+          "thumbnail-content" => "a_file.png"
+        })
+      end
+
+      it "converts content files into URLs" do
+        items = [{
+          "bendo-item" => "12345",
+          "content-file" => "a/file.txt"
+        },{
+        "bendo-item" => "12345",
+        "content-file" => "b/file.png",
+        "content-meta" => {
+          "mime-type" => "image/png"
+        }}]
+        after = @w.process(items, '')
+        expect(after.length).to eq(2)
+        expect(after.first).to eq({
+          "bendo-item" => "12345",
+          "content-meta" => {
+            "URL" => "bendo:/item/12345/a/file.txt"
+          }
+        })
+        expect(after.last).to eq({
+          "bendo-item" => "12345",
+          "content-meta" => {
+            "mime-type" => "image/png",
+            "URL" => "bendo:/item/12345/b/file.png"
+          }
+        })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+module ROF
+  module Filters
+    describe Label do
+      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"]}}])
+      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", "101"]
+               }},
+              {"type" => "fobject",
+               "pid" => "102",
+               "bendo-item" => "101",
+               "rels-ext" => {
+                 "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)"])
+
+        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"]}}
+        ])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+module ROF
+  module Filters
+    describe Work do
+      it "handles variant work types" do
+        w = Work.new
+
+        item = {"type" => "Work", "owner" => "user1"}
+        after = w.process_one_work(item)
+        expect(after.first).to include("type" => "fobject", "af-model" => "GenericWork")
+
+        item = {"type" => "Work-Image", "owner" => "user1"}
+        after = w.process_one_work(item)
+        expect(after.first).to include("type" => "fobject", "af-model" => "Image")
+
+        item = {"type" => "work-image", "owner" => "user1"}
+        after = w.process_one_work(item)
+        expect(after.first).to include("type" => "fobject", "af-model" => "image")
+
+        item = {"type" => "Image", "owner" => "user1"}
+        after = w.process_one_work(item)
+        expect(after.first).to include("type" => "fobject", "af-model" => "Image")
+
+        item = {"type" => "image", "owner" => "user1"}
+        after = w.process_one_work(item)
+        expect(after.first).to include("type" => "fobject", "af-model" => "Image")
+
+        item = {"type" => "Other", "owner" => "user1"}
+        after = w.process_one_work(item)
+        expect(after.first).to eq(item)
+      end
+
+      it "makes the first file be the representative" do
+        w = Work.new
+
+        item = {"type" => "Work", "owner" => "user1", "files" => ["a.txt", "b.jpeg"]}
+        after = w.process_one_work(item)
+        expect(after.length).to eq(3)
+        expect(after[0]).to include("type" => "fobject",
+                                    "af-model" => "GenericWork",
+                                    "pid" => "$(pid--0)",
+                                    "properties" => ROF::Utility.prop_ds("user1", "$(pid--1)"))
+        expect(after[1]).to include("type" => "fobject",
+                                    "af-model" => "GenericFile",
+                                    "pid" => "$(pid--1)")
+        expect(after[2]).to include("type" => "fobject",
+                                    "af-model" => "GenericFile")
+        expect(after[2]["metadata"]).to include("dc:title" => "b.jpeg")
+      end
+
+      it "decodes files correctly" do
+        w = Work.new
+
+        item = {
+          "type" => "Work",
+          "owner" => "user1",
+          "rights" => {"edit" => ["user1"]},
+          "metadata" => {
+            "@context" => RdfContext,
+            "dc:title" => "Q, A Letter"},
+            "files" => [
+              "thumb",
+              {
+                "type"  => "+",
+                "owner" => "user1",
+                "files" => ["extra file.txt"],
+                "rights" => {"edit" => ["user1"]}
+              }]
+        }
+        after = w.process_one_work(item)
+        expect(after.length).to eq(3)
+        expect(after[0]).to include("type" => "fobject",
+                                    "af-model" => "GenericWork",
+				    "rels-ext" => {}, 
+                                    "pid" => "$(pid--0)")
+        expect(after[1]).to include("type" => "fobject",
+                                    "af-model" => "GenericFile",
+                                    "pid" => "$(pid--1)",
+                                    "content-file" => "thumb")
+        expect(after[2]).to include("type" => "fobject",
+                                    "af-model" => "GenericFile",
+                                    "content-file" => "extra file.txt")
+      end
+    end
+  end
+end

data/spec/lib/rof/ingest_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+module ROF
+  describe "Ingest" do
+    it "requires a fobject" do
+      item = {"type" => "not fobject"}
+      expect {ROF.Ingest(item)}.to raise_error(ROF::NotFobjectError)
+    end
+    it "requires a pid" do
+      item = {"type" => "fobject"}
+      expect {ROF.Ingest(item)}.to raise_error(ROF::MissingPidError)
+    end
+    it "disallows both id and pid" do
+      item = {"type" => "fobject", "id" => '1', "pid" => '1'}
+      expect {ROF.Ingest(item)}.to raise_error(ROF::TooManyIdentitiesError)
+    end
+    it "rejects two ways of giving a datastream" do
+      item = {"type" => "fobject",
+              "pid" => "test:1",
+              "content" => "hello",
+              "content-file" => "filename.txt"
+      }
+      expect {ROF.Ingest(item)}.to raise_error(ROF::SourceError)
+    end
+    it "uploads datastreams with apropos metadata" do
+      item = {"type" => "fobject",
+              "pid" => "test:1",
+              "af-model" => "GenericFile",
+              "content" => "jello",
+              "content-meta" => {"label" => "test stream 1",
+                                 "mime-type" => "application/jello"},
+              "other-meta" => {"label" => "test stream 2"},
+      }
+      expect(ROF.Ingest(item)).to eq(["rels-ext", "content", "other"])
+    end
+
+    it "treats id as a surrogate for pid when pid is missing" do
+      item = {"type" => "fobject",
+              "id" => "test:1",
+              "af-model" => "GenericFile",
+              "content" => "jello",
+              "content-meta" => {"label" => "test stream 1",
+                                 "mime-type" => "application/jello"},
+              "other-meta" => {"label" => "test stream 2"},
+      }
+      expect(ROF.Ingest(item)).to eq(["rels-ext", "content", "other"])
+    end
+
+    it "doesn't touch the rels ext if the model and rels-ext key are missing" do
+      item = {"type" => "fobject",
+              "id" => "test:1",
+              "content" => "jello",
+              "content-meta" => {"label" => "test stream 1",
+                                 "mime-type" => "application/jello"},
+              "other-meta" => {"label" => "test stream 2"},
+      }
+      expect(ROF.Ingest(item)).to eq(["content", "other"])
+    end
+
+    it "raises an error if content is not a string" do
+      item = {"type" => "fobject",
+              "id" => "test:1",
+              "af-model" => "GenericFile",
+              "content" => ["list", "of", "items"]
+      }
+      expect {ROF.Ingest(item)}.to raise_error(ROF::SourceError)
+    end
+
+    it "ignores null data streams" do
+      item = {"type" => "fobject",
+              "id" => "test:1",
+              "af-model" => "GenericFile",
+              "content" => nil
+      }
+      expect(ROF.Ingest(item)).to eq(["rels-ext", "content"])
+    end
+
+    describe "RDF Metadata" do
+      it "loads JSON-LD" do
+        item = {"pid" => "test:1",
+          "metadata" => {
+            "@context" => {
+              "dc" => "http://purl.org/dc/terms/",
+            },
+            "dc:title" => "Hello Z",
+          }
+        }
+        s = ROF.ingest_ld_metadata(item, nil)
+        expect(s).to eq %(<info:fedora/test:1> <http://purl.org/dc/terms/title> "Hello Z" .\n)
+      end
+
+      it "handles @graph objects" do
+        item = {"pid" => "test:1",
+                "metadata" => {
+                  "@context" => {
+                    "dc" => "http://purl.org/dc/terms/",
+                    "dc:creator" => {"@type" => "@id"},
+                  },
+                  "@graph" => [
+                    {"@id" => "_:b0",
+                     "dc:title" => "Hello"},
+                    {"@id" => "info:fedora/test:1",
+                     "dc:creator" => "_:b0"},
+                  ]}}
+        s = ROF.ingest_ld_metadata(item, nil)
+        s = s.split("\n").sort.join("\n") # canonicalize the line ordering
+        expect(s).to eq %(<info:fedora/test:1> <http://purl.org/dc/terms/creator> _:b0 .\n_:b0 <http://purl.org/dc/terms/title> "Hello" .)
+      end
+    end
+  end
+
+  describe "file_searching" do
+    it "raises an error on missing files" do
+      expect {ROF.find_file_and_open("file.txt",[],"r")}.to raise_error(Errno::ENOENT)
+    end
+  end
+end