ezid-client 1.3.0 → 1.4.0

data/lib/ezid/metadata.rb

@@ -1,5 +1,4 @@
 require "hashie"
-require_relative "reserved_metadata"
 
 module Ezid
   #
@@ -8,7 +7,6 @@ module Ezid
   # @api private
   #
   class Metadata < Hashie::Mash
-    include ReservedMetadata
 
     # EZID metadata field/value separator
     ANVL_SEPARATOR = ": "
@@ -30,13 +28,35 @@ module Ezid
     # A line ending
     LINE_ENDING_RE = /\r?\n/
     # @api private
-    RESERVED_ALIASES = %w(
-      coowners datacenter export owner ownergroup
-      profile shadowedby shadows status target
-    ).freeze
 
-    def initialize(data={})
-      super coerce(data)
+    #
+    # EZID reserved metadata elements
+    #
+    # @see http://ezid.cdlib.org/doc/apidoc.html#internal-metadata
+    #
+    COOWNERS   = "_coowners".freeze
+    CREATED    = "_created".freeze
+    DATACENTER = "_datacenter".freeze
+    EXPORT     = "_export".freeze
+    OWNER      = "_owner".freeze
+    OWNERGROUP = "_ownergroup".freeze
+    PROFILE    = "_profile".freeze
+    SHADOWEDBY = "_shadowedby".freeze
+    SHADOWS    = "_shadows".freeze
+    STATUS     = "_status".freeze
+    TARGET     = "_target".freeze
+    UPDATED    = "_updated".freeze
+    RESERVED = [
+      COOWNERS, CREATED, DATACENTER, EXPORT, OWNER, OWNERGROUP,
+      PROFILE, SHADOWEDBY, SHADOWS, STATUS, TARGET, UPDATED
+    ].freeze
+    READONLY = [
+      CREATED, DATACENTER, OWNER, OWNERGROUP, SHADOWEDBY, SHADOWS, UPDATED
+    ].freeze
+
+    def initialize(data=nil)
+      super()
+      update(data) if data
     end
 
     def elements
@@ -53,6 +73,14 @@ module Ezid
       to_time(_updated)
     end
 
+    def update(data)
+      super coerce(data)
+    end
+
+    def replace(data)
+      super coerce(data)
+    end
+
     # Output metadata in EZID ANVL format
     # @see http://ezid.cdlib.org/doc/apidoc.html#request-response-bodies
     # @return [String] the ANVL output
@@ -74,13 +102,13 @@ module Ezid
 
     # Overrides Hashie::Mash
     def convert_key(key)
-      k = super
-      if RESERVED_ALIASES.include?(k)
-        "_#{k}"
-      elsif k =~ /\A(dc|datacite|erc)_/
-        k.sub(/_/, ".")
+      converted = super
+      if RESERVED.include?("_#{converted}")
+        "_#{converted}"
+      elsif converted =~ /\A(dc|datacite|erc)_/
+        converted.sub(/_/, ".")
       else
-        k
+        converted
       end
     end
 
@@ -93,9 +121,7 @@ module Ezid
 
     # Coerce data into a Hash of elements
     def coerce(data)
-      data.to_h
-    rescue NoMethodError
-      coerce_string(data)
+      data.respond_to?(:to_h) ? data.to_h : coerce_string(data)
     end
 
     # Escape string for sending to EZID host

data/lib/ezid/proxy_identifier.rb

@@ -1,6 +1,8 @@
 module Ezid
   class ProxyIdentifier
 
+    warn "[DEPRECATION] `Ezid::ProxyIdentifier` is deprecated and will be removed in v2.0. Use `Ezid::Identifier` instead."
+
     attr_reader :id
     attr_accessor :__real
 

data/lib/ezid/responses/response.rb

@@ -59,7 +59,7 @@ module Ezid
     # Returns an exception instance if there was an error
     # @return [Ezid::Error] the exception
     def exception
-      @exception ||= (error? && Error.new(message))
+      error_class.new(message) if error?
     end
 
     # The URI path of the request
@@ -68,5 +68,16 @@ module Ezid
       __getobj__.uri.path
     end
 
+    def error_class
+      case message
+      when /no such identifier/
+        IdentifierNotFoundError
+      when /identifier status does not support deletion/
+        DeletionError
+      else
+        Error
+      end
+    end
+
   end
 end

data/spec/integration/identifier_spec.rb

@@ -1,51 +1,47 @@
 module Ezid
   RSpec.describe Identifier do
 
+    before {
+      @identifier = described_class.mint(TEST_ARK_SHOULDER, target: "http://example.com")
+    }
+
     describe "CRUD operations" do
+      describe "mint" do
+        subject { @identifier }
+        it { is_expected.to be_a(described_class) }
+      end
       describe "create" do
-        describe "with a shoulder" do
-          subject { described_class.create(shoulder: TEST_ARK_SHOULDER) }
-          it "should mint an identifier" do
-            expect(subject).to be_a(described_class)
-            expect(subject.id).to match(/#{TEST_ARK_SHOULDER}/)
-          end
-        end
-        describe "with an id" do
-          let(:minted) { described_class.create(shoulder: TEST_ARK_SHOULDER) }
-          subject { described_class.create(id: "#{minted}/123") }
-          it "should create the identifier" do
-            expect(subject).to be_a(described_class)
-            expect(subject.id).to eq("#{minted}/123")
-          end
+        subject { described_class.create("#{@identifier}/123") }
+        it "should create the identifier" do
+          expect(subject).to be_a(described_class)
+          expect(subject.id).to eq("#{@identifier}/123")
         end
       end
-
       describe "retrieve" do
-        let(:minted) { described_class.create(shoulder: TEST_ARK_SHOULDER, target: "http://example.com") }
-        subject { described_class.find(minted.id) }
-        it "should instantiate the identifier" do
+        subject { described_class.find(@identifier.id) }
+        it "instantiates the identifier" do
           expect(subject).to be_a(described_class)
-          expect(subject.id).to eq(minted.id)
+          expect(subject.id).to eq(@identifier.id)
           expect(subject.target).to eq("http://example.com")
         end
       end
-
       describe "update" do
-        subject { described_class.create(shoulder: TEST_ARK_SHOULDER, target: "http://google.com") }
-        before do
-          subject.target = "http://example.com"
+        specify {
+          subject.target = "http://google.com"
           subject.save
-        end
-        it "should update the metadata" do
-          expect(subject.target).to eq("http://example.com")
-        end
+          expect(subject.target).to eq("http://google.com")
+        }
+        specify {
+          subject.update(target: "http://www.microsoft.com")
+          expect(subject.target).to eq("http://www.microsoft.com")
+        }
       end
-
       describe "delete" do
-        subject { described_class.create(shoulder: TEST_ARK_SHOULDER, status: "reserved") }
-        before { subject.delete }
-        it "should delete the identifier" do
-          expect { described_class.find(subject.id) }.to raise_error(Error)
+        subject { described_class.mint(TEST_ARK_SHOULDER, status: "reserved") }
+        it "deletes the identifier" do
+          subject.delete
+          expect(subject).to be_deleted
+          expect { described_class.find(subject.id) }.to raise_error(IdentifierNotFoundError)
         end
       end
     end

data/spec/spec_helper.rb

@@ -15,6 +15,8 @@
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 
+require "rspec/its"
+
 require "ezid/test_helper"
 ezid_test_mode!
 

data/spec/unit/batch_download_spec.rb

@@ -0,0 +1,5 @@
+module Ezid
+  RSpec.describe BatchDownload do
+    # TODO
+  end
+end

data/spec/unit/identifier_spec.rb

@@ -1,283 +1,349 @@
 module Ezid
   RSpec.describe Identifier do
-
-    describe ".create" do
-      let(:attrs) { {shoulder: TEST_ARK_SHOULDER, profile: "dc", target: "http://example.com"} }
-      it "instantiates a new Identifier and saves it" do
-        expect(described_class).to receive(:new).with(attrs).and_call_original
-        expect_any_instance_of(described_class).to receive(:save) { double }
-        described_class.create(attrs)
+    describe "class methods" do
+      describe ".create" do
+        let(:args) { ["id", {profile: "dc", target: "http://example.com"}] }
+        it "instantiates a new Identifier and saves it" do
+          expect_any_instance_of(described_class).to receive(:save) { double(id: "id") }
+          described_class.create(*args)
+        end
       end
-    end
-
-    describe ".find" do
-      it "instantiates a new identifier and loads the metadata" do
-        expect(described_class).to receive(:new).with(id: "id").and_call_original
-        expect_any_instance_of(described_class).to receive(:load_metadata) { double }
-        described_class.find("id")
+      describe ".mint" do
+        let(:attrs) { {profile: "dc", target: "http://example.com"} }
+        let(:args) { [TEST_ARK_SHOULDER, attrs] }
+        it "instantiates a new Identifier and saves it" do
+          expect_any_instance_of(described_class).to receive(:save) { double(id: "id") }
+          described_class.mint(*args)
+        end
       end
-    end
-
-    describe ".defaults" do
-      before { @original_defaults = described_class.defaults }
-      after { described_class.defaults = @original_defaults }
-      it "can be set via client config" do
-        Client.config.identifier.defaults = {status: "reserved"}
-        expect(described_class.defaults).to eq({status: "reserved"})
+      describe ".modify" do
+        let(:args) { ["id", {profile: "dc", target: "http://example.com"}] }
+        it "instantiates a new Indentifier and modifies it" do
+          expect_any_instance_of(described_class).not_to receive(:save)
+          expect_any_instance_of(described_class).to receive(:modify!)
+          described_class.modify(*args)
+        end
+      end
+      describe ".find" do
+        it "instantiates a new identifier and loads the metadata" do
+          expect_any_instance_of(described_class).to receive(:id=).with("id").and_call_original
+          expect_any_instance_of(described_class).to receive(:load_metadata) {
+            double(id: "id", metadata: nil)
+          }
+          described_class.find("id")
+        end
+      end
+      describe ".defaults" do
+        before { @original_defaults = described_class.defaults }
+        after { described_class.defaults = @original_defaults }
+        it "can be set via client config" do
+          Client.config.identifier.defaults = {status: "reserved"}
+          expect(described_class.defaults).to eq({status: "reserved"})
+        end
       end
     end
 
-    describe "#initialize" do
-      describe "with metadata" do
-        describe "via the :metadata argument" do
-          subject { described_class.new(metadata: "_profile: dc\n_target: http://example.com") }
-          it "sets the metadata" do
-            expect(subject.profile).to eq("dc")
-            expect(subject.target).to eq("http://example.com")
+    describe "instance methods" do
+      describe "#initialize" do
+        before {
+          allow(described_class).to receive(:defaults) { defaults }
+        }
+        let(:defaults) { {} }
+        describe "with no arguments" do
+          its(:id) { is_expected.to be_nil }
+          describe "and no default metadata" do
+            its(:metadata) { is_expected.to be_empty }
           end
-        end
-        describe "via keyword arguments" do
-          subject { described_class.new(profile: "dc", target: "http://example.com") }
-          it "sets the metadata" do
-            expect(subject.profile).to eq("dc")
-            expect(subject.target).to eq("http://example.com")
+          describe "and with default metadata" do
+            let(:defaults) { {export: "no"} }
+            its(:metadata) { is_expected.to eq({"_export"=>"no"}) }
           end
         end
-      end
-      describe "default metadata" do
-        before do
-          allow(described_class).to receive(:defaults) { {profile: "dc", status: "reserved"} }
+        describe "with an id and no metadata" do
+          subject { described_class.new("id") }
+          its(:id) { is_expected.to eq("id") }
+          describe "and no default metadata" do
+            its(:metadata) { is_expected.to be_empty }
+          end
+          describe "and with default metadata" do
+            let(:defaults) { {export: "no"} }
+            its(:metadata) { is_expected.to eq({"_export"=>"no"}) }
+          end
         end
-        it "sets the default metadata" do
-          expect(subject.profile).to eq("dc")
-          expect(subject.status).to eq("reserved")
+        describe "with an id and metadata" do
+          subject { described_class.new("id", metadata: "_profile: dc\n_target: http://example.com", status: "reserved") }
+          its(:id) { is_expected.to eq("id") }
+          describe "and no default metadata" do
+            its(:metadata) { is_expected.to eq("_profile"=>"dc", "_target"=>"http://example.com", "_status"=>"reserved") }
+          end
+          describe "and with default metadata" do
+            let(:defaults) { {export: "no", status: "public"} }
+            its(:metadata) { is_expected.to eq("_profile"=>"dc", "_target"=>"http://example.com", "_status"=>"reserved", "_export"=>"no") }
+          end
         end
-        context "when explicit arguments override the defaults" do
-          subject { described_class.new(shoulder: TEST_ARK_SHOULDER, status: "public") }
-          it "overrides the defaults" do
-            expect(subject.profile).to eq("dc")
-            expect(subject.status).to eq("public")
+        describe "with only metadata" do
+          subject { described_class.new(metadata: "_profile: dc\n_target: http://example.com", status: "reserved") }
+          its(:id) { is_expected.to be_nil }
+          describe "and no default metadata" do
+            its(:metadata) { is_expected.to eq("_profile"=>"dc", "_target"=>"http://example.com", "_status"=>"reserved") }
+          end
+          describe "and with default metadata" do
+            let(:defaults) { {export: "no", status: "public"} }
+            its(:metadata) { is_expected.to eq("_profile"=>"dc", "_target"=>"http://example.com", "_status"=>"reserved", "_export"=>"no") }
           end
         end
       end
-    end
 
-    describe "#update" do
-      let(:metadata) { {"status" => "unavailable"} }
-      subject { described_class.new(id: "id") }
-      it "updates the metadata and saves" do
-        expect(subject).to receive(:update_metadata).with(metadata)
-        expect(subject).to receive(:save) { double }
-        subject.update(metadata)
+      describe "#update" do
+        let(:metadata) { {"status" => "unavailable"} }
+        subject { described_class.new(id: "id") }
+        it "updates the metadata and saves" do
+          expect(subject).to receive(:update_metadata).with(metadata)
+          expect(subject).to receive(:save) { double }
+          subject.update(metadata)
+        end
       end
-    end
 
-    describe "#update_metadata" do
-      it "updates the metadata" do
-        subject.update_metadata(:status => "public", _target: "localhost", "dc.creator" => "Me")
-        expect(subject.metadata.to_h).to eq({"_status"=>"public", "_target"=>"localhost", "dc.creator"=>"Me"})
+      describe "#modify!" do
+        describe "when the Identifier has no id" do
+          specify {
+            expect { subject.modify! }.to raise_error(Error)
+          }
+        end
+        describe "when the Identifier has an id" do
+          specify {
+            subject.id = "id"
+            expect(subject).not_to receive(:save)
+            expect(subject).to receive(:modify)
+            subject.modify!
+          }
+          describe "when the identifier does not exist" do
+            specify {
+              subject.id = "id"
+              allow(subject.client).to receive(:modify_identifier).and_raise(IdentifierNotFoundError)
+              expect { subject.modify! }.to raise_error(IdentifierNotFoundError)
+            }
+          end
+        end
       end
-    end
 
-    describe "#load_metadata" do
-      let(:metadata) { "_profile: erc" }
-      before { allow(subject).to receive(:id) { "id" } }
-      it "initializes the metadata from EZID" do
-        expect(subject.client).to receive(:get_identifier_metadata).with("id") { double(id: "id", metadata: metadata) }
-        expect(Metadata).to receive(:new).with(metadata)
-        subject.load_metadata
+      describe "#update_metadata" do
+        it "updates the metadata" do
+          subject.update_metadata(:status => "public", _target: "localhost", "dc.creator" => "Me")
+          expect(subject.metadata.to_h).to eq({"_status"=>"public", "_target"=>"localhost", "dc.creator"=>"Me"})
+        end
       end
-    end
 
-    describe "#reset" do
-      before { subject.metadata = Metadata.new(status: "public") }
-      it "clears the local metadata" do
-        expect { subject.reset }.to change { subject.metadata.empty? }.from(false).to(true)
+      describe "#load_metadata" do
+        let(:metadata) { "_profile: erc" }
+        before { allow(subject).to receive(:id) { "id" } }
+        it "replaces the remote metadata with metadata from EZID" do
+          expect(subject.client).to receive(:get_identifier_metadata).with("id") { double(id: "id", metadata: metadata) }
+          expect(subject.remote_metadata).to receive(:replace).with(metadata)
+          subject.load_metadata
+        end
       end
-    end
 
-    describe "#persisted?" do
-      describe "after initialization" do
-        it { is_expected.not_to be_persisted }
-      end
-      describe "when saving an unpersisted object" do
-        before { allow(subject).to receive(:create_or_mint) { nil } }
-        it "marks it as persisted" do
-          expect { subject.save }.to change(subject, :persisted?).from(false).to(true)
+      describe "#reset_metadata" do
+        before {
+          subject.status = "public"
+          subject.remote_metadata.profile = "dc"
+        }
+        it "clears the local metadata" do
+          expect { subject.reset_metadata }
+            .to change { subject.metadata.empty? }
+                 .from(false).to(true)
+        end
+        it "clears the remote metadata" do
+          expect { subject.reset_metadata }
+            .to change { subject.remote_metadata.empty? }
+                 .from(false).to(true)
         end
       end
-      describe "when saving a persisted object" do
-        before do
-          allow(subject).to receive(:persisted?) { true }
-          allow(subject).to receive(:modify) { nil }
+
+      describe "#persisted?" do
+        describe "after initialization" do
+          it { is_expected.not_to be_persisted }
         end
-        it "does not change the persisted status" do
-          expect { subject.save }.not_to change(subject, :persisted?)
+        describe "when saving an unpersisted object" do
+          before {
+            allow(subject.client).to receive(:mint_identifier) { double(id: "id") }
+            subject.save
+          }
+          it { is_expected.to be_persisted }
+        end
+        describe "when saving a persisted object" do
+          before do
+            allow(subject).to receive(:persisted?) { true }
+            allow(subject).to receive(:modify) { nil }
+          end
+          it "does not change the persisted status" do
+            expect { subject.save }.not_to change(subject, :persisted?)
+          end
         end
       end
-    end
 
-    describe "#delete" do
-      context "when the identifier is reserved" do
-        subject { described_class.new(id: "id", status: Status::RESERVED) }
-        context "and is persisted" do
-          before { allow(subject).to receive(:persisted?) { true } }
-          it "deletes the identifier" do
-            expect(subject.client).to receive(:delete_identifier).with("id") { double(id: "id") }
-            subject.delete
-            expect(subject).to be_deleted
+      describe "#delete" do
+        context "when the identifier is reserved" do
+          subject { described_class.new("id", status: Status::RESERVED) }
+          context "and is persisted" do
+            before { allow(subject).to receive(:persisted?) { true } }
+            it "deletes the identifier" do
+              expect(subject.client).to receive(:delete_identifier).with("id") { double(id: "id") }
+              subject.delete
+              expect(subject).to be_deleted
+            end
+          end
+          context "and is not persisted" do
+            before { allow(subject).to receive(:persisted?) { false } }
+            it "raises an exception" do
+              expect { subject.delete }.to raise_error(Error)
+            end
           end
         end
-        context "and is not persisted" do
-          before { allow(subject).to receive(:persisted?) { false } }
+        context "when identifier is not reserved" do
+          subject { described_class.new(id: "id", status: Status::PUBLIC) }
           it "raises an exception" do
             expect { subject.delete }.to raise_error(Error)
           end
         end
       end
-      context "when identifier is not reserved" do
-        subject { described_class.new(id: "id", status: Status::PUBLIC) }
-        it "raises an exception" do
-          expect { subject.delete }.to raise_error(Error)
-        end
-      end
-    end
 
-    describe "#save" do
-      context "when the identifier is persisted" do
-        let(:metadata) { Metadata.new }
-        before do
-          allow(subject).to receive(:id) { "id" }
-          allow(subject).to receive(:persisted?) { true }
-          allow(subject).to receive(:metadata) { metadata }
-        end
-        it "modifies the identifier" do
-          expect(subject.client).to receive(:modify_identifier).with("id", metadata) { double(id: "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 { allow(subject).to receive(:id) { "id" } }
-          it "creates the identifier" do
-            expect(subject.client).to receive(:create_identifier).with("id", subject.metadata) { double(id: "id") }
+      describe "#save" do
+        context "when the identifier is persisted" do
+          let(:metadata) { Metadata.new }
+          before do
+            allow(subject).to receive(:id) { "id" }
+            allow(subject).to receive(:persisted?) { true }
+            allow(subject).to receive(:metadata) { metadata }
+          end
+          it "modifies the identifier" do
+            expect(subject.client).to receive(:modify_identifier).with("id", metadata) { double(id: "id") }
             subject.save
           end
         end
-        context "and `id' is not present" do
-          context "and `shoulder' is present" do
-            before { allow(subject).to receive(:shoulder) { TEST_ARK_SHOULDER } }
-            it "mints the identifier" do
-              expect(subject.client).to receive(:mint_identifier).with(TEST_ARK_SHOULDER, subject.metadata) { double(id: "id") }
+        context "when the identifier is not persisted" do
+          before do
+            allow(subject).to receive(:persisted?) { false }
+          end
+          context "and `id' is present" do
+            before { allow(subject).to receive(:id) { "id" } }
+            it "creates the identifier" do
+              expect(subject.client).to receive(:create_identifier).with("id", subject.metadata) { double(id: "id") }
               subject.save
             end
           end
-          context "and `shoulder' is not present" do
-            before { allow(Client.config).to receive(:default_shoulder) { nil } }
-            it "raises an exception" do
-              expect { subject.save }.to raise_error(Error)
+          context "and `id' is not present" do
+            context "and `shoulder' is present" do
+              before { allow(subject).to receive(:shoulder) { TEST_ARK_SHOULDER } }
+              it "mints the identifier" do
+                expect(subject.client).to receive(:mint_identifier).with(TEST_ARK_SHOULDER, subject.metadata) { double(id: "id") }
+                subject.save
+              end
+            end
+            context "and `shoulder' is not present" do
+              before { allow(Client.config).to receive(:default_shoulder) { nil } }
+              it "raises an exception" do
+                expect { subject.save }.to raise_error(Error)
+              end
             end
           end
         end
       end
-    end
 
-    describe "boolean status methods" do
-      context "when the identifier is public" do
-        before { subject.public! }
-        it { is_expected.to be_public }
-        it { is_expected.not_to be_reserved }
-        it { is_expected.not_to be_unavailable }
-      end
-      context "when the identifier is reserved" do
-        before { subject.status = Status::RESERVED }
-        it { is_expected.not_to be_public }
-        it { is_expected.to be_reserved }
-        it { is_expected.not_to be_unavailable }
-      end
-      context "when the identifier is unavailable" do
-        context "and it has no reason" do
-          before { subject.unavailable! }
-          it { is_expected.not_to be_public }
+      describe "boolean status methods" do
+        context "when the identifier is public" do
+          before { subject.public! }
+          it { is_expected.to be_public }
           it { is_expected.not_to be_reserved }
-          it { is_expected.to be_unavailable }
+          it { is_expected.not_to be_unavailable }
         end
-        context "and it has a reason" do
-          before { subject.unavailable!("withdrawn") }
+        context "when the identifier is reserved" do
+          before { subject.status = Status::RESERVED }
           it { is_expected.not_to be_public }
-          it { is_expected.not_to be_reserved }
-          it { is_expected.to be_unavailable }
+          it { is_expected.to be_reserved }
+          it { is_expected.not_to be_unavailable }
+        end
+        context "when the identifier is unavailable" do
+          context "and it has no reason" do
+            before { subject.unavailable! }
+            it { is_expected.not_to be_public }
+            it { is_expected.not_to be_reserved }
+            it { is_expected.to be_unavailable }
+          end
+          context "and it has a reason" do
+            before { subject.unavailable!("withdrawn") }
+            it { is_expected.not_to be_public }
+            it { is_expected.not_to be_reserved }
+            it { is_expected.to be_unavailable }
+          end
         end
       end
-    end
 
-    describe "status-changing methods" do
-      subject { described_class.new(id: "id", status: status) }
-      describe "#unavailable!" do
-        context "when the status is \"unavailable\"" do
-          let(:status) { "#{Status::UNAVAILABLE} | whatever" }
-          context "and no reason is given" do
-            it "logs a warning" do
-              pending "https://github.com/duke-libraries/ezid-client/issues/46"
-              allow_message_expectations_on_nil
-              expect(subject.logger).to receive(:warn)
-              subject.unavailable!
+      describe "status-changing methods" do
+        subject { described_class.new(id: "id", status: status) }
+        describe "#unavailable!" do
+          context "when the status is \"unavailable\"" do
+            let(:status) { "#{Status::UNAVAILABLE} | whatever" }
+            context "and no reason is given" do
+              it "logs a warning" do
+                pending "https://github.com/duke-libraries/ezid-client/issues/46"
+                allow_message_expectations_on_nil
+                expect(subject.logger).to receive(:warn)
+                subject.unavailable!
+              end
+              it "does not change the status" do
+                expect { subject.unavailable! }.not_to change(subject, :status)
+              end
             end
-            it "does not change the status" do
-              expect { subject.unavailable! }.not_to change(subject, :status)
+            context "and a reason is given" do
+              it "logs a warning" do
+                pending "https://github.com/duke-libraries/ezid-client/issues/46"
+                allow_message_expectations_on_nil
+                expect(subject.logger).to receive(:warn)
+                subject.unavailable!("because")
+              end
+              it "should change the status" do
+                expect { subject.unavailable!("because") }.to change(subject, :status).from(status).to("#{Status::UNAVAILABLE} | because")
+              end
             end
           end
-          context "and a reason is given" do
-            it "logs a warning" do
-              pending "https://github.com/duke-libraries/ezid-client/issues/46"
-              allow_message_expectations_on_nil
-              expect(subject.logger).to receive(:warn)
-              subject.unavailable!("because")
+          context "when the status is \"reserved\"" do
+            let(:status) { Status::RESERVED }
+            context "and persisted" do
+              before { allow(subject).to receive(:persisted?) { true } }
+              it "raises an exception" do
+                expect { subject.unavailable! }.to raise_error(Error)
+              end
             end
-            it "should change the status" do
-              expect { subject.unavailable!("because") }.to change(subject, :status).from(status).to("#{Status::UNAVAILABLE} | because")
+            context "and not persisted" do
+              before { allow(subject).to receive(:persisted?) { false } }
+              it "changes the status" do
+                expect { subject.unavailable! }.to change(subject, :status).from(Status::RESERVED).to(Status::UNAVAILABLE)
+              end
             end
           end
-        end
-        context "when the status is \"reserved\"" do
-          let(:status) { Status::RESERVED }
-          context "and persisted" do
-            before { allow(subject).to receive(:persisted?) { true } }
-            it "raises an exception" do
-              expect { subject.unavailable! }.to raise_error(Error)
+          context "when the status is \"public\"" do
+            let(:status) { Status::PUBLIC }
+            context "and no reason is given" do
+              it "changes the status" do
+                expect { subject.unavailable! }.to change(subject, :status).from(Status::PUBLIC).to(Status::UNAVAILABLE)
+              end
             end
-          end
-          context "and not persisted" do
-            before { allow(subject).to receive(:persisted?) { false } }
-            it "changes the status" do
-              expect { subject.unavailable! }.to change(subject, :status).from(Status::RESERVED).to(Status::UNAVAILABLE)
+            context "and a reason is given" do
+              it "changes the status and appends the reason" do
+                expect { subject.unavailable!("withdrawn") }.to change(subject, :status).from(Status::PUBLIC).to("#{Status::UNAVAILABLE} | withdrawn")
+              end
             end
           end
         end
-        context "when the status is \"public\"" do
-          let(:status) { Status::PUBLIC }
-          context "and no reason is given" do
-            it "changes the status" do
-              expect { subject.unavailable! }.to change(subject, :status).from(Status::PUBLIC).to(Status::UNAVAILABLE)
-            end
+        describe "#public!" do
+          subject { described_class.new(id: "id", status: Status::UNAVAILABLE) }
+          it "changes the status" do
+            expect { subject.public! }.to change(subject, :status).from(Status::UNAVAILABLE).to(Status::PUBLIC)
           end
-          context "and a reason is given" do
-            it "changes the status and appends the reason" do
-              expect { subject.unavailable!("withdrawn") }.to change(subject, :status).from(Status::PUBLIC).to("#{Status::UNAVAILABLE} | withdrawn")
-            end
-          end
-        end
-      end
-      describe "#public!" do
-        subject { described_class.new(id: "id", status: Status::UNAVAILABLE) }
-        it "changes the status" do
-          expect { subject.public! }.to change(subject, :status).from(Status::UNAVAILABLE).to(Status::PUBLIC)
         end
       end
     end
-
   end
 end