ezid-client 0.3.0 → 0.4.0

data/lib/ezid/request.rb

@@ -1,3 +1,4 @@
+require "delegate"
 require "uri"
 require "net/http"
 
@@ -5,50 +6,35 @@ module Ezid
   #
   # A request to the EZID service.
   #
-  # @note A Request should only be created by an Ezid::Client instance.
   # @api private
-  class Request
+  class Request < SimpleDelegator
 
-    EZID_HOST = "ezid.cdlib.org"
+    HOST = "https://ezid.cdlib.org"
     CHARSET = "UTF-8"
     CONTENT_TYPE = "text/plain"
 
-    attr_reader :http_request, :uri, :operation
-
-    def initialize(*args)
-      @operation = args
-      http_method, path, query = Api.send(*args)
-      @uri = URI::HTTPS.build(host: EZID_HOST, path: path, query: query)
-      @http_request = Net::HTTP.const_get(http_method).new(uri)
-      @http_request.set_content_type(CONTENT_TYPE, charset: CHARSET)
+    def self.execute(*args)
+      request = new(*args)
+      yield request if block_given?
+      request.execute
     end
 
-    # Executes the request and returns the HTTP response
-    # @return [Net::HTTPResponse] the response
-    def execute
-      Net::HTTP.start(uri.host, use_ssl: true) do |http|
-        http.request(http_request)
-      end
+    # @param method [Symbol] the Net::HTTP constant for the request method
+    # @param path [String] the uri path (including query string, if any)
+    def initialize(method, path)
+      http_method = Net::HTTP.const_get(method)
+      uri = URI.parse([HOST, path].join)
+      super(http_method.new(uri))
+      set_content_type(CONTENT_TYPE, charset: CHARSET)
     end
 
-    # Adds authentication data to the request
-    # @param opts [Hash] the options.
-    #   Must include either: `:cookie`, or: `:user` and `:password`.
-    # @option opts [String] :cookie a session cookie
-    # @option opts [String] :user user name for basic auth
-    # @option opts [String] :password password for basic auth
-    def add_authentication(opts={})
-      if opts[:cookie]
-        http_request["Cookie"] = opts[:cookie]
-      else
-        http_request.basic_auth(opts[:user], opts[:password])
+    # Executes the request and returns the response
+    # @return [Ezid::Response] the response
+    def execute
+      http_response = Net::HTTP.start(uri.host, use_ssl: true) do |http|
+        http.request(__getobj__)
       end
-    end
-
-    # Adds EZID metadata (if any) to the request body
-    # @param metadata [Ezid::Metadata] the metadata to add
-    def add_metadata(metadata)
-      http_request.body = metadata.to_anvl unless metadata.empty?
+      Response.new(http_response)
     end
 
   end

data/lib/ezid/response.rb

@@ -4,7 +4,6 @@ module Ezid
   #
   # A response from the EZID service.
   #
-  # @note A Response should only be created by an Ezid::Client instance.
   # @api private
   class Response < SimpleDelegator
 
@@ -14,6 +13,21 @@ module Ezid
     # Error response status
     ERROR = "error"
 
+    IDENTIFIER_RE = /^(doi|ark|urn):[^\s]+/
+    SHADOW_ARK_RE = /\| (ark:[^\s]+)/
+
+    def id
+      @id ||= IDENTIFIER_RE.match(message)[0]
+    end
+
+    def shadow_ark
+      @shadow_ark ||= SHADOW_ARK_RE.match(message)[1]
+    end
+
+    def metadata
+      content[1]
+    end
+
     # The response status -- "success" or "error"
     # @return [String] the status
     def status
@@ -23,7 +37,7 @@ module Ezid
     # The status line of the response
     # @return [String] the status line
     def status_line
-      content.first
+      content[0]
     end
 
     # The body of the response split into: status line and rest of body
@@ -32,45 +46,45 @@ module Ezid
       @content ||= body.split(/\r?\n/, 2)
     end
 
-    # Metadata (if any) parsed out of the response
-    # @return [Ezid::Metadata] the metadata
-    def metadata
-      return @metadata if @metadata
-      if success? && identifier_uri?
-        @metadata = Metadata.new(content.last) 
-      end
-      @metadata
-    end
-
-    # The identifier string parsed out of the response
-    # @return [String] the identifier
-    def identifier
-      message.split(/\s/).first if success? && identifier_uri?
-    end
-
-    def identifier_uri?
-      ( uri.path =~ /^\/(id|shoulder)\// ) && true
-    end
-
+    # The outcome of the request - "success" or "error"
+    # @return [String] the outcome
     def outcome
       status.first
     end
 
+    # The EZID status message
+    # @return [String] the message
     def message
       status.last
     end
 
-    def cookie
-      self["Set-Cookie"].split(";").first rescue nil
-    end
-
+    # Whether the outcome was an error
+    # @return [Boolean]
     def error?
       outcome == ERROR
     end
 
+    # Whether the outcome was a success
+    # @return [Boolean]
     def success?
       outcome == SUCCESS
     end
 
+    # Returns an exception instance if there was an error
+    # @return [Ezid::Error] the exception
+    def exception
+      @exception ||= (error? && Error.new(message))
+    end
+
+    # The URI path of the request
+    # @return [String] the path
+    def uri_path
+      __getobj__.uri.path
+    end
+
+    def cookie
+      self["Set-Cookie"].split(";").first rescue nil
+    end
+
   end
 end

data/lib/ezid/session.rb

@@ -1,8 +1,3 @@
-require "uri"
-require "net/http"
-
-require_relative "request"
-
 module Ezid
   #
   # An EZID session
@@ -20,9 +15,8 @@ module Ezid
       super.sub(/@cookie="[^\"]+"/, "OPEN")
     end
 
-    def open(response)
-      # XXX raise exception if no cookie?
-      @cookie = response.cookie if response.cookie
+    def open(cookie)
+      @cookie = cookie
     end
 
     def close

data/lib/ezid/status.rb

@@ -0,0 +1,23 @@
+module Ezid
+  class Status < SimpleDelegator
+
+    SUBSYSTEMS = %w( noid ldap datacite )
+
+    SUBSYSTEMS.each do |s|
+      define_method(s) { subsystems[s] || "not checked" }
+    end
+
+    def subsystems
+      return {} unless content[1]
+      content[1].split(/\r?\n/).each_with_object({}) do |line, memo| 
+        subsystem, status = line.split(": ", 2)
+        memo[subsystem] = status
+      end
+    end
+
+    def up?
+      success?
+    end
+
+  end
+end

data/spec/lib/ezid/client_spec.rb

@@ -1,90 +1,181 @@
 module Ezid
   RSpec.describe Client do
+
     describe "initialization" do
       describe "without a block" do
-        it "should not be logged in" do
-          expect(subject).not_to be_logged_in
+        it "should not login" do
+          expect_any_instance_of(described_class).not_to receive(:login)
+          described_class.new
         end
       end
-      describe "with a block", :vcr do
-        it "should be logged in" do
+      describe "with a block", type: :feature do
+        it "should wrap the block in a session" do
+          expect_any_instance_of(described_class).to receive(:login).and_call_original
+          expect_any_instance_of(described_class).to receive(:logout).and_call_original
           described_class.new do |client|
-            expect(client).to be_logged_in
+            expect(client.session).to be_open
           end
         end
       end
     end    
-    describe "authentication", :vcr do
-      describe "logging in" do
-        before { subject.login }
-        it "should be logged in" do
-          expect(subject).to be_logged_in
+
+    describe "authentication", type: :feature do
+      describe "#login" do
+        it "should open a session" do
+          expect(subject.session).to be_closed
+          subject.login
+          expect(subject.session).to be_open
         end
       end
-      describe "logging out" do
+      describe "#logout" do
         before { subject.login }
-        it "should not be logged in" do
+        it "should close the session" do
+          expect(subject.session).to be_open
           subject.logout
-          expect(subject).not_to be_logged_in
+          expect(subject.session).to be_closed
+        end
+      end
+      describe "without a session" do
+        it "should send the user name and password" do
+          expect_any_instance_of(Net::HTTP::Post).to receive(:basic_auth).with(subject.user, subject.password).and_call_original
+          subject.mint_identifier(ARK_SHOULDER)
         end
       end
     end
-    describe "creating an identifier", :vcr do
-      # TODO
+
+    describe "#create_identifier" do
+      let(:id) { "ark:/99999/fk4fn19h88" }
+      let(:http_response) { double(body: "success: ark:/99999/fk4fn19h88") }
+      let(:stub_response) { Response.new(http_response) }
+      before do
+        allow(Request).to receive(:execute) { stub_response }
+      end
+      subject { described_class.new.create_identifier(id) }
+      it "should be a success" do
+        expect(subject).to be_success
+        expect(subject.id).to eq(id)
+      end
     end
-    describe "minting an identifier", :vcr do
+
+    describe "#mint_identifier" do
+      before { allow(Request).to receive(:execute) { stub_response } }
       describe "which is an ARK" do
-        it "should be a success" do
-          response = subject.mint_identifier(ARK_SHOULDER)
-          expect(response).to be_success
-          expect(response.message).to match(/#{ARK_SHOULDER}/)
+        let(:stub_response) { Response.new(double(body: "success: ark:/99999/fk4fn19h88")) }
+        subject { described_class.new.mint_identifier(ARK_SHOULDER) }
+        it "should be a succes" do
+          expect(subject).to be_success
+          expect(subject.id).to eq("ark:/99999/fk4fn19h88")
         end
       end
       describe "which is a DOI" do
-        it "should be a sucess" do
-          response = subject.mint_identifier(DOI_SHOULDER, doi_metadata)
-          expect(response).to be_success
-          expect(response.message).to match(/#{DOI_SHOULDER}/)
-          expect(response.message).to match(/\| ark:/)
+        let(:http_response) { double(body: "success: doi:10.5072/FK2TEST | ark:/99999/fk4fn19h88") }
+        let(:stub_response) { Response.new(http_response) }
+        let(:metadata) do
+          <<-EOS
+datacite.title: Test
+datacite.creator: Duke
+datacite.publisher: Duke
+datacite.publicationyear: 2014
+datacite.resourcetype: Other
+EOS
+        end
+        subject { described_class.new.mint_identifier(DOI_SHOULDER, metadata) }
+        it "should be a sucess" do          
+          expect(subject).to be_success
+          expect(subject.id).to eq("doi:10.5072/FK2TEST")
+          expect(subject.shadow_ark).to eq("ark:/99999/fk4fn19h88")
         end
       end
     end
-    describe "getting identifier metadata" do
+
+    describe "#get_identifier_metadata" do
+      let(:stub_response) do
+        Response.new(double(body: <<-EOS
+success: ark:/99999/fk4fn19h88
+_updated: 1416507086
+_target: http://ezid.cdlib.org/id/ark:/99999/fk4fn19h88
+_profile: erc
+_ownergroup: apitest
+_owner: apitest
+_export: yes
+_created: 1416507086
+_status: public
+EOS
+                                     )) 
+      end
       before do
-        @identifier = subject.mint_identifier(ARK_SHOULDER).identifier
+        allow(Request).to receive(:execute) { stub_response }
       end
-      it "should return the metadata" do
-        response = subject.get_identifier_metadata(@identifier)
-        expect(response.body).to match(/_status: public/)
+      subject { described_class.new.get_identifier_metadata("ark:/99999/fk4fn19h88") }
+      it "should retrieve the metadata" do
+        expect(subject.metadata).to eq <<-EOS
+_updated: 1416507086
+_target: http://ezid.cdlib.org/id/ark:/99999/fk4fn19h88
+_profile: erc
+_ownergroup: apitest
+_owner: apitest
+_export: yes
+_created: 1416507086
+_status: public
+EOS
       end
     end
-    describe "modifying an identifier" do
+
+    describe "#modify_identifier", type: :feature do
       before do
-        @identifier = subject.mint_identifier(ARK_SHOULDER).identifier
+        @id = described_class.new.mint_identifier(ARK_SHOULDER).id
       end
+      subject { described_class.new.modify_identifier(@id, "dc.title" => "Test") }
       it "should update the metadata" do
-        subject.modify_identifier(@identifier, "dc.title" => "Test")
-        response = subject.get_identifier_metadata(@identifier)
-        expect(response.body).to match(/dc.title: Test/)
+        expect(subject).to be_success
+        response = described_class.new.get_identifier_metadata(@id)
+        expect(response.metadata).to match(/dc.title: Test/)
       end
     end
-    describe "deleting an identifier" do
+
+    describe "#delete_identifier", type: :feature do
       before do
-        @identifier = subject.mint_identifier(ARK_SHOULDER, "_status" => "reserved").identifier 
+        @id = described_class.new.mint_identifier(ARK_SHOULDER, "_status" => "reserved").id
       end
+      subject { described_class.new.delete_identifier(@id) }
       it "should delete the identifier" do
-        response = subject.delete_identifier(@identifier) 
-        expect(response).to be_success
-        expect { subject.get_identifier_metadata(@identifier) }.to raise_error
+        expect(subject).to be_success
+        expect { described_class.new.get_identifier_metadata(@id) }.to raise_error
       end
     end
-    describe "server status", :vcr do
+
+    describe "server status" do
+      let(:http_response) do
+        double(body: <<-EOS
+success: EZID is up
+noid: up
+ldap: up
+EOS
+               ) 
+      end
+      let(:stub_response) { Response.new(http_response) }
+      before do
+        allow(Request).to receive(:execute) { stub_response }
+      end
+      subject { described_class.new.server_status("*") }
       it "should report the status of EZID and subsystems" do
-        response =  subject.server_status("*")
-        expect(response).to be_success
-        expect(response.message).to eq("EZID is up")
+        expect(subject).to be_success
+        expect(subject).to be_up
+        expect(subject.message).to eq("EZID is up")
+        expect(subject.noid).to eq("up")
+        expect(subject.ldap).to eq("up")
+        expect(subject.datacite).to eq("not checked")
+      end
+    end
+
+    describe "error handling" do
+      let(:stub_response) { Response.new(body: "error: bad request - no such identifier") }
+      before do
+        allow(Request).to receive(:execute) { stub_response } 
+      end
+      it "should raise an exception" do
+        expect { subject.get_identifier_metadata("invalid") }.to raise_error
       end
     end
   end
 end
-