ezid-client 0.3.0 → 0.4.0

data/spec/lib/ezid/identifier_spec.rb

@@ -0,0 +1,203 @@
+module Ezid
+  RSpec.describe Identifier do
+
+    describe ".create" do
+      describe "when given an id" do
+        let(:id) { "ark:/99999/fk4zzzzzzz" }
+        subject { described_class.create(id: id) }
+        before do
+          allow_any_instance_of(Client).to receive(:create_identifier).with(id, {}) { double(id: id) }
+          allow_any_instance_of(Client).to receive(:get_identifier_metadata).with(id) { double(metadata: {}) }
+        end
+        it "should create an identifier" do
+          expect(subject).to be_a(described_class)
+          expect(subject.id).to eq(id)
+        end
+      end
+      describe "when given a shoulder (and no id)" do
+        let(:id) { "ark:/99999/fk4fn19h88" }
+        subject { described_class.create(shoulder: ARK_SHOULDER) }
+        before do
+          allow_any_instance_of(Client).to receive(:mint_identifier).with(ARK_SHOULDER, {}) { double(id: id) }
+          allow_any_instance_of(Client).to receive(:get_identifier_metadata).with(id) { double(metadata: {}) }
+        end
+        it "should mint an identifier" do
+          expect(subject).to be_a(described_class)
+          expect(subject.id).to eq(id)
+        end
+      end
+      describe "when given neither an id nor a shoulder" do
+        it "should raise an exception" do
+          expect { described_class.create }.to raise_error
+        end
+      end
+      describe "with metadata" do
+        it "should send the metadata"
+      end
+    end
+
+    describe ".find" do
+      describe "when the id exists" do
+        let(:id) { "ark:/99999/fk4fn19h88" }
+        subject { described_class.find(id) }
+        before do
+          allow_any_instance_of(Client).to receive(:get_identifier_metadata).with(id) { double(id: id, metadata: {}) }
+        end
+        it "should get the identifier" do
+          expect(subject).to be_a(Identifier)
+          expect(subject.id).to eq(id)
+        end
+      end
+      describe "when the id does not exist" do
+        let(:id) { "ark:/99999/fk4zzzzzzz" }
+        before do
+          allow_any_instance_of(Client).to receive(:get_identifier_metadata).with(id).and_raise(Error)
+        end
+        it "should raise an exception" do
+          expect { described_class.find(id) }.to raise_error
+        end
+      end
+    end
+    
+    describe "#update" do
+      let(:id) { "ark:/99999/fk4fn19h88" }
+      let(:metadata) { {"_status" => "unavailable"} }
+      subject { described_class.new(id: id) }
+      before do
+        allow(subject).to receive(:persisted?) { true }
+        allow(subject.client).to receive(:modify_identifier).with(id, subject.metadata) do
+          double(id: id, metadata: {})
+        end
+      end
+      it "should update the metadata" do
+        expect(subject.metadata).to receive(:update).with(metadata)
+        subject.update(metadata)
+      end
+      it "should save the identifier" do
+        expect(subject).to receive(:save)
+        subject.update(metadata)
+      end
+    end
+
+    describe "#reload" do
+      let(:id) { "ark:/99999/fk4fn19h88" }
+      let(:metadata) { "_created: 1416507086" }
+      subject { described_class.new(id: id) }
+      before do
+        allow(subject.client).to receive(:get_identifier_metadata).with(id) { double(metadata: metadata) }
+      end
+      it "should update the metadata from EZID" do
+        expect(subject.metadata).to receive(:replace).with(metadata)
+        subject.reload
+      end
+    end
+
+    describe "#reset" do
+      it "should clear the local metadata" do
+        expect(subject.metadata).to receive(:clear)
+        subject.reset
+      end
+    end
+
+    describe "#persisted?" do
+      it "should be false if id is nil" do
+        expect(subject).not_to be_persisted
+      end
+      context "when `created' is nil" do
+        before { allow(subject).to receive(:id) { "ark:/99999/fk4fn19h88" } }
+        it "should be false" do
+          expect(subject).not_to be_persisted
+        end
+      end
+      context "when id and `created' are present" do
+        before do
+          allow(subject).to receive(:id) { "ark:/99999/fk4fn19h88" }
+          allow(subject.metadata).to receive(:created) { Time.at(1416507086) }
+        end
+        it "should be true" do
+          expect(subject).to be_persisted
+        end
+      end
+    end
+
+    describe "#delete" do
+      let(:id) { "ark:/99999/fk4zzzzzzz" }
+      subject { described_class.new(id: id, status: "reserved") }
+      before do
+        allow_any_instance_of(Client).to receive(:delete_identifier).with(id) { double(id: id) }
+      end
+      it "should delete the identifier" do
+        expect(subject.client).to receive(:delete_identifier).with(id)
+        subject.delete
+        expect(subject).to be_deleted
+      end
+    end
+
+    describe "#save" do
+      let(:id) { "ark:/99999/fk4zzzzzzz" }
+      before do
+        allow(subject.client).to receive(:get_identifier_metadata).with(id) { double(metadata: {}) }
+      end
+      context "when the identifier is persisted" do
+        before do
+          allow_any_instance_of(Client).to receive(:modify_identifier).with(id, {}) { double(id: id) }
+          allow(subject).to receive(:id) { id }
+          allow(subject).to receive(:persisted?) { true }
+        end
+        it "should modify the identifier" do
+          expect(subject.client).to receive(:modify_identifier).with(id, {})
+          subject.save
+        end
+      end
+      context "when the identifier is not persisted" do
+        before do
+          allow(subject).to receive(:persisted?) { false }
+        end
+        context "and `id' is present" do
+          before do
+            allow(subject).to receive(:id) { id }
+            allow_any_instance_of(Client).to receive(:create_identifier).with(id, {}) { double(id: id) }
+          end
+          it "should create the identifier" do
+            expect(subject.client).to receive(:create_identifier).with(id, {})
+            subject.save
+          end
+        end
+        context "and `id' is not present" do
+          context "and `shoulder' is present" do
+            before do
+              allow(subject).to receive(:shoulder) { ARK_SHOULDER }
+              allow_any_instance_of(Client).to receive(:mint_identifier).with(ARK_SHOULDER, {}) { double(id: id) }
+            end
+            it "should mint the identifier" do
+              expect(subject.client).to receive(:mint_identifier).with(ARK_SHOULDER, {})
+              subject.save
+            end
+          end
+          context "and `shoulder' is not present" do
+            it "should raise an exception" do
+              expect { subject.save }.to raise_error
+            end
+          end
+        end
+      end
+    end
+
+    it "should handle CRUD operations", type: :feature do
+      # create (mint)
+      identifier = Ezid::Identifier.create(shoulder: ARK_SHOULDER)
+      expect(identifier.status).to eq("public")
+      # update
+      identifier.target = "http://example.com"
+      identifier.save
+      # retrieve
+      identifier = Ezid::Identifier.find(identifier.id)
+      expect(identifier.target).to eq("http://example.com")
+      # delete
+      identifier = Ezid::Identifier.create(shoulder: ARK_SHOULDER, status: "reserved")
+      identifier.delete
+      expect { Ezid::Identifier.find(identifier.id) }.to raise_error
+    end
+
+  end
+end

data/spec/lib/ezid/metadata_spec.rb

@@ -11,31 +11,37 @@ module Ezid
           "_created" => "1416507086",
           "_status" => "public" }
     end
-    before { subject.instance_variable_set(:@elements, elements) }
-    describe "#status" do
-      it "should return the status" do
-        expect(subject.status).to eq("public")
-      end
-    end
-    describe "#target" do
-      it "should return the target URL" do
-        expect(subject.target).to eq("http://ezid.cdlib.org/id/ark:/99999/fk4fn19h87")
-      end
+    subject { described_class.new(elements) }
+
+    it "should have a non-leading-underscore reader for each reserved element, except '_crossref'" do
+      Metadata::RESERVED_ELEMENTS.each do |element|
+        next if element == "_crossref"
+        expect(subject).to respond_to(element.sub("_", ""))
+      end      
     end
-    describe "#profile" do
-      it "should return the profile" do
-        expect(subject.profile).to eq("erc")
+
+    describe "element reader aliases for datetime elements" do
+      it "should return Time values" do
+        expect(subject.created).to eq Time.parse("2014-11-20 13:11:26 -0500")
+        expect(subject.updated).to eq Time.parse("2014-11-20 13:11:26 -0500")
       end
     end
-    describe "#created" do
-      it "should return the creation time" do
-        expect(subject.created).to be_a(Time)
-      end
+
+    it "should have a non-leading-underscore writer for each writable reserved element, except '_crossref'" do
+      Metadata::RESERVED_READWRITE_ELEMENTS.each do |element|
+        next if element == "_crossref"
+        expect(subject).to respond_to("#{element.sub('_', '')}=")
+      end      
+    end    
+
+    describe "#update" do
+      it "should coerce the data"
+      it "should update the delegated hash"
     end
-    describe "#updated" do
-      it "should return the last update time" do
-        expect(subject.updated).to be_a(Time)
-      end
+
+    describe "#replace" do
+      it "should coerce the data"
+      it "should call `replace' on the delegated hash"
     end
 
     describe "ANVL output" do
@@ -52,11 +58,11 @@ _status: public")
       end
       describe "encoding" do
         before do
-          subject.each_key { |k| subject[k] = subject[k].force_encoding("US_ASCII") }
+          subject.each_key { |k| subject[k] = subject[k].force_encoding(Encoding::US_ASCII) }
+        end
+        it "should be encoded in UTF-8" do
+          expect(subject.to_anvl.encoding).to eq(Encoding::UTF_8)
         end
-      end
-      it "should be encoded in UTF-8" do
-        expect(subject.to_anvl.encoding).to eq(Encoding::UTF_8)
       end
       describe "escaping" do
         before do
@@ -78,6 +84,12 @@ _status: public")
 
     describe "coercion" do
       subject { described_class.new(data) }
+      context "of nil" do
+        let(:data) { nil }
+        it "should return an empty hash" do
+          expect(subject).to eq({})
+        end
+      end
       context "of a string" do
         let(:data) do <<-EOS
 _updated: 1416507086
@@ -91,14 +103,14 @@ _status: public
 EOS
         end
         it "should coerce the data into a hash" do
-          expect(subject.elements).to eq({"_updated" => "1416507086",
-                                           "_target" => "http://ezid.cdlib.org/id/ark:/99999/fk4fn19h87",
-                                           "_profile" => "erc",
-                                           "_ownergroup" => "apitest",
-                                           "_owner" => "apitest",
-                                           "_export" => "yes",
-                                           "_created" => "1416507086",
-                                           "_status" => "public"})
+          expect(subject).to eq({"_updated" => "1416507086",
+                                 "_target" => "http://ezid.cdlib.org/id/ark:/99999/fk4fn19h87",
+                                 "_profile" => "erc",
+                                 "_ownergroup" => "apitest",
+                                 "_owner" => "apitest",
+                                 "_export" => "yes",
+                                 "_created" => "1416507086",
+                                 "_status" => "public"})
         end
       end
       context "of a hash" do
@@ -113,14 +125,161 @@ EOS
             _status: "public" }
         end
         it "should stringify the keys" do
-          expect(subject.elements).to eq({"_updated" => "1416507086",
-                                           "_target" => "http://ezid.cdlib.org/id/ark:/99999/fk4fn19h87",
-                                           "_profile" => "erc",
-                                           "_ownergroup" => "apitest",
-                                           "_owner" => "apitest",
-                                           "_export" => "yes",
-                                           "_created" => "1416507086",
-                                           "_status" => "public"})
+          expect(subject).to eq({"_updated" => "1416507086",
+                                  "_target" => "http://ezid.cdlib.org/id/ark:/99999/fk4fn19h87",
+                                  "_profile" => "erc",
+                                  "_ownergroup" => "apitest",
+                                  "_owner" => "apitest",
+                                  "_export" => "yes",
+                                  "_created" => "1416507086",
+                                  "_status" => "public"})
+        end
+      end
+      context "of a Metadata instance" do
+        let(:hsh) do 
+          { "_updated" => "1416507086",
+            "_target" => "http://ezid.cdlib.org/id/ark:/99999/fk4fn19h87",
+            "_profile" => "erc",
+            "_ownergroup" => "apitest",
+            "_owner" => "apitest",
+            "_export" => "yes",
+            "_created" => "1416507086",
+            "_status" => "public" }
+        end
+        let(:data) { Metadata.new(hsh) }
+        it "should have the same hash" do
+          expect(subject).to eq(hsh)
+        end
+      end
+    end
+
+    describe "profiles" do
+      describe "dc" do
+        describe "readers" do
+          before do
+            subject.update("dc.title" => "Testing Profiles",
+                           "dc.creator" => "Kermit the Frog",
+                           "dc.publisher" => "Duke University",
+                           "dc.date" => "2004",
+                           "dc.type" => "Text")
+          end
+          it "should have a reader for each element" do
+            expect(subject.dc_title).to eq("Testing Profiles")
+            expect(subject.dc_creator).to eq("Kermit the Frog")
+            expect(subject.dc_publisher).to eq("Duke University")
+            expect(subject.dc_date).to eq("2004")
+            expect(subject.dc_type).to eq("Text")
+          end
+        end
+        describe "writers" do
+          before do
+            subject.dc_title = "Run of the Mill"
+            subject.dc_creator = "Jack Bean"
+            subject.dc_publisher = "Random Housing"
+            subject.dc_date = "1967"
+            subject.dc_type = "Physical Object"
+          end
+          it "should have a writer for each element" do
+            expect(subject["dc.title"]).to eq "Run of the Mill"
+            expect(subject["dc.creator"]).to eq "Jack Bean"
+            expect(subject["dc.publisher"]).to eq "Random Housing"
+            expect(subject["dc.date"]).to eq "1967"
+            expect(subject["dc.type"]).to eq "Physical Object"
+          end
+        end
+      end
+      describe "erc" do
+        describe "readers" do
+          before do
+            subject.update("erc.what" => "Testing Profiles",
+                            "erc.who" => "Kermit the Frog",
+                            "erc.when" => "2004")
+          end
+          it "should have a reader for each element" do
+            expect(subject.erc_what).to eq("Testing Profiles")
+            expect(subject.erc_who).to eq("Kermit the Frog")
+            expect(subject.erc_when).to eq("2004")
+          end
+        end
+        describe "writers" do
+          before do
+            subject.erc_what = "Run of the Mill"
+            subject.erc_who = "Jack Bean"
+            subject.erc_when = "1967"
+          end
+          it "should have a writer for each element" do
+            expect(subject["erc.what"]).to eq "Run of the Mill"
+            expect(subject["erc.who"]).to eq "Jack Bean"
+            expect(subject["erc.when"]).to eq "1967"
+          end
+        end
+      end
+      describe "crossref" do
+        describe "xml document reader" do
+          before do
+            subject["crossref"] = "<xml/>" 
+          end
+          it "should return the xml" do
+            expect(subject.crossref).to eq "<xml/>"
+        end
+      end
+      describe "xml document writer" do
+        before do
+          subject.crossref = "<yml/>"
+        end
+        it "should set the 'crossref' metadata element" do
+          expect(subject["crossref"]).to eq "<yml/>"
+        end
+      end
+      end
+      describe "datacite" do
+        describe "element readers" do
+          before do
+            subject.update("datacite.title" => "Testing Profiles",
+                           "datacite.creator" => "Kermit the Frog",
+                           "datacite.publisher" => "Duke University",
+                           "datacite.publicationyear" => "2004",
+                           "datacite.resourcetype" => "Text")
+          end
+          it "should have a reader for each element" do
+            expect(subject.datacite_title).to eq("Testing Profiles")
+            expect(subject.datacite_creator).to eq("Kermit the Frog")
+            expect(subject.datacite_publisher).to eq("Duke University")
+            expect(subject.datacite_publicationyear).to eq("2004")
+            expect(subject.datacite_resourcetype).to eq("Text")
+          end
+        end
+        describe "element writers" do
+          before do
+            subject.datacite_title = "Run of the Mill"
+            subject.datacite_creator = "Jack Bean"
+            subject.datacite_publisher = "Random Housing"
+            subject.datacite_publicationyear = "1967"
+            subject.datacite_resourcetype = "Physical Object"
+          end
+          it "should have a writer for each element" do
+            expect(subject["datacite.title"]).to eq "Run of the Mill"
+            expect(subject["datacite.creator"]).to eq "Jack Bean"
+            expect(subject["datacite.publisher"]).to eq "Random Housing"
+            expect(subject["datacite.publicationyear"]).to eq "1967"
+            expect(subject["datacite.resourcetype"]).to eq "Physical Object"
+          end
+        end
+        describe "xml document reader" do
+          before do
+            subject["datacite"] = "<xml/>" 
+          end
+          it "should return the xml" do
+            expect(subject.datacite).to eq "<xml/>"
+          end
+        end
+        describe "xml document writer" do
+          before do
+            subject.datacite = "<yml/>"
+          end
+          it "should set the 'datacite' metadata element" do
+            expect(subject["datacite"]).to eq "<yml/>"
+          end
         end
       end
     end