dor-workflow-service 1.8.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: abb7f9fafd6a57bbe2ce009a7f3d8bca21680383
-  data.tar.gz: 4c7ca111d9dbf464495a22eeb7a40bad80f8a805
+  metadata.gz: 6cdb8d9e4d0b767532df5ea3f4c8e090b2120353
+  data.tar.gz: 0bbd9f050f133cd1f2c924832bc4f2f390150398
 SHA512:
-  metadata.gz: 008f69b8e8cf014a2d2490417b0812d34ef88bd731b5b9cbad822fec2938c6d4e5a9f7ef3bb3f78942a909b64ff625b8594f6f5f39a5edb689a7c603badc366e
-  data.tar.gz: 24ad2b473ff2507560897f0704c4c8813adb1b1092dccafea7eb49c565c3382ba936bf54991d4f226d19b59f42c49f2c1d018b732a6bd421877aa9c72da81103
+  metadata.gz: 31e2c9ccbd940d6e1335797e68fb173a564fb70d8684b23135d58090552ba4a8f617da7e3492fdad44572022f7ac7a78b43ca73b01d80c036c8a3cd5e12ad291
+  data.tar.gz: ce17ca0ce0d966e5076e19d3d92b6ca38d082c6d5891bf4b123e05e39a3bb1b8b2085617a30002b101465f1c180df8017c939f2b26a0b5c3f6682daafdb64259

data/dor-workflow-service.gemspec

@@ -19,7 +19,6 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency 'activesupport', '>= 3.2.1', '< 5'
   gem.add_dependency 'nokogiri', '~> 1.6.0'
-  gem.add_dependency 'rest-client', '~> 1.7'
   gem.add_dependency 'retries'
   gem.add_dependency 'confstruct', '>= 0.2.7', '< 2'
   gem.add_dependency 'faraday', '~> 0.9.2'
@@ -30,4 +29,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'yard'
   gem.add_development_dependency 'redcarpet'
   gem.add_development_dependency 'equivalent-xml', '~> 0.5.1'
+  gem.add_development_dependency 'simplecov'
 end

data/lib/dor/services/workflow_service.rb

@@ -1,10 +1,9 @@
-require 'rest-client'
 require 'active_support'
 require 'active_support/core_ext'
 require 'nokogiri'
 require 'retries'
 require 'faraday'
-require 'net/http/persistent'
+require 'dor/workflow_exception'
 
 module Dor
 
@@ -13,7 +12,7 @@ module Dor
   # TODO: create normal initalize method, deprecate configure
   # TODO: hardcoded 'true' returns are dumb, instead return the response object where possible
   # TODO: VALID_STATUS should be just another attribute w/ default
-  # TODO: allow constructor/initalizer to receive RestClient::Resource object(s), not just URLs (solves SSL/proxy config problem)
+  # TODO: allow constructor/initalizer to receive Faraday object(s), not just URLs (solves SSL/proxy config problem)
   # TODO: allow constructor/initalizer to receive logger
 
   # Create and update workflows
@@ -46,7 +45,7 @@ module Dor
       def create_workflow(repo, druid, workflow_name, wf_xml, opts = {:create_ds => true})
         lane_id = opts.fetch(:lane_id, 'default')
         xml = add_lane_id_to_workflow_xml(lane_id, wf_xml)
-        workflow_resource_method "#{repo}/objects/#{druid}/workflows/#{workflow_name}", 'put', xml,
+        status = workflow_resource_method "#{repo}/objects/#{druid}/workflows/#{workflow_name}", 'put', xml,
           {
             :content_type => 'application/xml',
             :params       => { 'create-ds' => opts[:create_ds] }
@@ -97,7 +96,7 @@ module Dor
       def get_workflow_status(repo, druid, workflow, process)
         workflow_md = get_workflow_xml(repo, druid, workflow)
         doc = Nokogiri::XML(workflow_md)
-        raise Exception.new("Unable to parse response:\n#{workflow_md}") if doc.root.nil?
+        raise Dor::WorkflowException.new("Unable to parse response:\n#{workflow_md}") if doc.root.nil?
         status = doc.root.at_xpath("//process[@name='#{process}']/@status")
         status = status.content if status
         status
@@ -280,7 +279,6 @@ module Dor
         uri_string << "&limit=#{options[:limit].to_i}"  if options[:limit] && options[:limit].to_i > 0
         uri_string << "&lane-id=#{lane_id}"
 
-        workflow_resource.options[:timeout] = 5 * 60 unless workflow_resource.options.include?(:timeout)
         resp = workflow_resource_method uri_string
         #
         # response looks like:
@@ -324,7 +322,7 @@ module Dor
       #
       # @return [Integer] Number of objects with this repository:workflow:step that have a status of 'error'
       def count_errored_for_workstep(workflow, step, repository = 'dor')
-        count_objects_in_step(workflow, step, repository, 'error')
+        count_objects_in_step(workflow, step, 'error', repository)
       end
 
       # Returns the number of objects that have a status of 'queued' in a particular workflow and step
@@ -335,7 +333,17 @@ module Dor
       #
       # @return [Integer] Number of objects with this repository:workflow:step that have a status of 'queued'
       def count_queued_for_workstep(workflow, step, repository = 'dor')
-        count_objects_in_step(workflow, step, repository, 'queued')
+        count_objects_in_step(workflow, step, 'queued', repository)
+      end
+
+      ##
+      # Returns the number of objects that have completed a particular workflow
+      # @param [String] workflow name
+      # @param [String] repository -- optional, default=dor
+      # @return [Integer] Number of objects with this repository:workflow that have been archived
+      def count_archived_for_workflow(workflow, repository = 'dor')
+        resp = workflow_resource_method "workflow_archive?repository=#{repository}&workflow=#{workflow}&count-only=true"
+        extract_object_count(resp)
       end
 
       # Gets all of the workflow steps that have a status of 'queued' that have a last-updated timestamp older than the number of hours passed in
@@ -395,10 +403,9 @@ module Dor
       # @param [String] druid The id of the object to delete the workflow from
       def archive_workflow(repo, druid, wf_name, version_num = nil)
         raise 'Please call Dor::WorkflowService.configure(workflow_service_url, :dor_services_url => DOR_SERVIES_URL) once before archiving workflow' if @@dor_services_url.nil?
-        dor_services = RestClient::Resource.new(@@dor_services_url)
         url = "/v1/objects/#{druid}/workflows/#{wf_name}/archive"
         url << "/#{version_num}" if version_num
-        dor_services[url].post ''
+        workflow_resource_method(url, 'post', '')
       end
 
       # Calls the versionClose endpoint of the WorkflowService:
@@ -430,10 +437,16 @@ module Dor
       end
 
       ### MIMICKING ATTRIBUTE READER
-      # @return [RestClient::Resource] the REST client resource created during configure()
+      # @return [Faraday::Connection] the REST client resource created during configure()
       def workflow_resource
-        raise 'Please call Dor::WorkflowService.configure(url) once before calling any WorkflowService methods' if @@resource.nil?
-        @@resource
+        raise 'Please call Dor::WorkflowService.configure(url) once before calling any WorkflowService methods' if @@http_conn.nil?
+        @@http_conn
+      end
+
+      ##
+      # Get the configured URL for the connection
+      def base_url
+        workflow_resource.url_prefix
       end
 
       # Among other things, a distinct method helps tests mock default logger
@@ -445,7 +458,7 @@ module Dor
       end
 
       def workflow_service_exceptions_to_catch
-        [RestClient::Exception]
+        [Faraday::Error]
       end
 
       # Configure the workflow service
@@ -454,14 +467,12 @@ module Dor
       # @param [Hash] opts optional params
       # @option opts [Logger] :logger defaults writing to workflow_service.log with weekly rotation
       # @option opts [String] :dor_services_url uri to the DOR REST service
-      # @option opts [Integer] :timeout number of seconds for RestClient timeout
+      # @option opts [Integer] :timeout number of seconds for HTTP timeout
       # @option opts [String] :client_cert_file path to an SSL client certificate (deprecated)
       # @option opts [String] :client_key_file path to an SSL key file (deprecated)
       # @option opts [String] :client_key_pass password for the key file (deprecated)
-      # @return [RestClient::Resource] the REST client resource
-      def configure(url, opts = {})
-        params = {}
-        params[:timeout]   = opts[:timeout] if opts[:timeout]
+      # @return [Faraday::Connection] the REST client resource
+      def configure(url_or_connection, opts = {})
         @@logger           = opts[:logger] || default_logger
         @@dor_services_url = opts[:dor_services_url] if opts[:dor_services_url]
         # params[:ssl_client_cert] = OpenSSL::X509::Certificate.new(File.read(opts[:client_cert_file])) if opts[:client_cert_file]
@@ -469,11 +480,20 @@ module Dor
         @@handler = Proc.new do |exception, attempt_number, total_delay|
           @@logger.warn "[Attempt #{attempt_number}] #{exception.class}: #{exception.message}; #{total_delay} seconds elapsed."
         end
-        @@resource = RestClient::Resource.new(url, params)
-        @@http_conn = Faraday.new(url: url) do |faraday|
-          faraday.response :logger if opts[:debug] # logs to STDOUT
-          faraday.adapter  :net_http_persistent    # use Keep-Alive connections
-        end
+        @@http_conn = case url_or_connection
+                      when String
+                        Faraday.new(url: url_or_connection) do |faraday|
+                          faraday.response :logger if opts[:debug] # logs to STDOUT
+                          faraday.adapter  :net_http_persistent    # use Keep-Alive connections
+                          faraday.use Faraday::Response::RaiseError
+                          if opts.key? :timeout
+                            faraday.options.timeout = opts[:timeout]
+                            faraday.options.open_timeout = opts[:timeout]
+                          end
+                        end
+                      else
+                        url_or_connection
+                      end
       end
 
 
@@ -511,8 +531,12 @@ module Dor
 
       def count_objects_in_step(workflow, step, type, repo)
         resp = workflow_resource_method "workflow_queue?repository=#{repo}&workflow=#{workflow}&#{type}=#{step}"
+        extract_object_count(resp)
+      end
+
+      def extract_object_count(resp)
         node = Nokogiri::XML(resp).at_xpath('/objects')
-        raise 'Unable to determine count from response' if node.nil?
+        raise Dor::WorkflowException.new('Unable to determine count from response') if node.nil?
         node['count'].to_i
       end
 
@@ -525,21 +549,23 @@ module Dor
       # @return [Object] response from method
       def workflow_resource_method(uri_string, meth = 'get', payload = '', opts = {})
         with_retries(:max_tries => 2, :handler => @@handler, :rescue => workflow_service_exceptions_to_catch) do |attempt|
-          @@logger.info "[Attempt #{attempt}] #{meth} #{workflow_resource.url}/#{uri_string}"
-          if meth == 'get'
-            fail NotImplementedError, "GET does not support extra headers: #{opts}" unless opts.length == 0
-            @@logger.debug "Persistent HTTP GET #{uri_string} (#{@@http_conn.inspect})"
-            @@http_conn.get(uri_string).body
-          elsif meth == 'delete'
-            workflow_resource[uri_string].send(meth, opts)
-          elsif opts.size == 0    # the right number of args allows existing test expect/with statements to continue working
-            workflow_resource[uri_string].send(meth, payload)
-          else
-            workflow_resource[uri_string].send(meth, payload, opts)
+          @@logger.info "[Attempt #{attempt}] #{meth} #{base_url}/#{uri_string}"
+
+          response = workflow_resource.send(meth, uri_string) do |req|
+            req.body = payload unless meth == 'delete'
+
+            req.params.update opts[:params] if opts[:params]
+
+            req.headers.update opts.except(:params)
           end
+
+          response.body
         end
+      rescue *workflow_service_exceptions_to_catch => e
+        msg = "Failed to retrieve resource: #{meth} #{base_url}/#{uri_string}"
+        msg += " (HTTP status #{e.response[:status]})" if e.respond_to?(:response) && e.response
+        raise Dor::WorkflowException, msg
       end
-
     end
   end
 end

data/lib/dor/workflow_exception.rb

@@ -0,0 +1,4 @@
+module Dor
+  class WorkflowException < ::RuntimeError
+  end
+end

data/lib/dor/workflow_version.rb

@@ -1,7 +1,7 @@
 module Dor
   module Workflow
     module Service
-      VERSION = '1.8.0'
+      VERSION = '2.0.0'
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,10 +1,14 @@
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'spec'
+end
+
 require 'dor-workflow-service'
 require 'equivalent-xml'
 require 'equivalent-xml/rspec_matchers'
 
 # RSpec.configure do |conf|
 # end
-

data/spec/workflow_service_spec.rb

@@ -24,50 +24,65 @@ describe Dor::WorkflowService do
     EOXML
   }
 
+  let(:stubs) do
+    Faraday::Adapter::Test::Stubs.new
+  end
+
+  let(:mock_http_connection) do
+    Faraday.new(url: 'http://example.com/') do |builder|
+      builder.use Faraday::Response::RaiseError
+
+      builder.adapter :test, stubs
+    end
+  end
+
   before(:each) do
     @repo  = 'dor'
     @druid = 'druid:123'
-    @mock_resource = double('mock_rest_client_resource')
-    @mock_http_connection = double('mock_http_connection')
     @mock_logger = double('Logger')
 
     allow(@mock_logger).to receive(:info)  # silence log output
     allow(@mock_logger).to receive(:debug) # silence log output
+    allow(@mock_logger).to receive(:warn) # silence log output
     allow(Dor::WorkflowService).to receive(:default_logger).and_return(@mock_logger)
 
-    allow(@mock_resource).to receive(:[]).and_return(@mock_resource)
-    allow(@mock_resource).to receive(:options).and_return( {} )
-    allow(@mock_resource).to receive(:url).and_return( 'https://localhost/workflow' )
-
-    allow(Faraday).to receive(:new).and_return(@mock_http_connection)
+    Dor::WorkflowService.configure mock_http_connection
+  end
 
-    allow(RestClient::Resource).to receive(:new).and_return(@mock_resource)
-    Dor::WorkflowService.configure @mock_resource.url
+  describe '#configure' do
+    it 'should handle a string and timeout' do
+      conn = Dor::WorkflowService.configure 'http://externalhost/', :timeout => 99
+      expect(conn).to be_a(Faraday::Connection)
+      expect(conn.options.timeout).to eq(99)
+      expect(conn.options.open_timeout).to eq(99)
+    end
   end
 
   describe '#create_workflow' do
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.put("#{@repo}/objects/#{@druid}/workflows/etdSubmitWF") { |env| [201, {}, ''] }
+        stub.put("#{@repo}/objects/#{@druid}/workflows/noCreateDsWF?create-ds=false") { |env| [201, {}, ''] }
+        stub.put("#{@repo}/objects/#{@druid}/workflows/httpException") { |env| [418, {}, "I'm A Teapot"] }
+        stub.put("#{@repo}/objects/#{@druid}/workflows/raiseException") { |env| raise 'broken' }
+      end
+    end
+
     it 'should pass workflow xml to the DOR workflow service and return the URL to the workflow' do
-      expect(@mock_resource).to receive(:put).with(wf_xml_label, anything).and_return('')
       Dor::WorkflowService.create_workflow(@repo, @druid, 'etdSubmitWF', wf_xml)
     end
 
-    it 'should log an error and retry upon a targetted RestClient exception, raise on an unexpected Exception' do
-      ex = RestClient::Exception.new(nil, 418)
-      ex.message = "I'm A Teapot"
-      runs = 0
-      expect(@mock_resource).to receive(:put).twice {
-        runs += 1
-        raise ex if runs == 1
-        raise Exception.new('Something Else Happened') if runs == 2
-      }
-      expect(@mock_logger).to receive(:warn).with(/\[Attempt 1\] RestClient::Exception: #{ex.message}/)
-      expect{ Dor::WorkflowService.create_workflow(@repo, @druid, 'etdSubmitWF', wf_xml) }.to raise_error(Exception, 'Something Else Happened')
+    it 'should log an error and retry upon a targetted Faraday exception' do
+      expect(@mock_logger).to receive(:warn).with(/\[Attempt 1\] Faraday::ClientError: the server responded with status 418/)
+      expect { Dor::WorkflowService.create_workflow(@repo, @druid, 'httpException', wf_xml) }.to raise_error Dor::WorkflowException
+    end
+
+    it 'should raise on an unexpected Exception' do
+      expect{ Dor::WorkflowService.create_workflow(@repo, @druid, 'raiseException', wf_xml) }.to raise_error(Exception, 'broken')
     end
 
     it 'sets the create-ds param to the value of the passed in options hash' do
-      expect(@mock_resource).to receive(:put).with(wf_xml_label, :content_type => 'application/xml',
-                                                :params => {'create-ds' => false}).and_return('')
-      Dor::WorkflowService.create_workflow(@repo, @druid, 'etdSubmitWF', wf_xml, :create_ds => false)
+      Dor::WorkflowService.create_workflow(@repo, @druid, 'noCreateDsWF', wf_xml, :create_ds => false)
     end
 
     it 'adds lane_id attributes to all steps if passed in as an option' do
@@ -91,102 +106,207 @@ describe Dor::WorkflowService do
   end
 
   describe '#update_workflow_status' do
-    before :each do
-      @xml_re = /name="reader-approval"/
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.put("#{@repo}/objects/#{@druid}/workflows/etdSubmitWF/reader-approval?current-status=queued") do |env|
+          [201, {}, '']
+        end
+
+        stub.put("#{@repo}/objects/#{@druid}/workflows/etdSubmitWF/reader-approval") do |env|
+          expect(env.body).to eq "<?xml version=\"1.0\"?>\n<process name=\"reader-approval\" status=\"completed\" elapsed=\"0\" note=\"annotation\" version=\"2\" laneId=\"lane2\"/>\n"
+          [201, {}, '']
+        end
+
+        stub.put("#{@repo}/objects/#{@druid}/workflows/errorWF/reader-approval") do |env|
+          [400, {}, '']
+        end
+      end
     end
 
     it 'should update workflow status and return true if successful' do
-      built_xml = "<?xml version=\"1.0\"?>\n<process name=\"reader-approval\" status=\"completed\" elapsed=\"0\" note=\"annotation\" version=\"2\" laneId=\"lane2\"/>\n"
-      expect(@mock_resource).to receive(:put).with(built_xml, { :content_type => 'application/xml' }).and_return('')
       expect(Dor::WorkflowService.update_workflow_status(@repo, @druid, 'etdSubmitWF', 'reader-approval', 'completed', :version => 2, :note => 'annotation', :lane_id => 'lane2')).to be true
     end
 
     it 'should return false if the PUT to the DOR workflow service throws an exception' do
-      ex = Exception.new('exception thrown')
-      expect(@mock_resource).to receive(:put).with(@xml_re, { :content_type => 'application/xml' }).and_raise(ex)
-      expect{ Dor::WorkflowService.update_workflow_status(@repo, @druid, 'etdSubmitWF', 'reader-approval', 'completed') }.to raise_error(Exception, 'exception thrown')
+      expect{ Dor::WorkflowService.update_workflow_status(@repo, @druid, 'errorWF', 'reader-approval', 'completed') }.to raise_error(Dor::WorkflowException, /status 400/)
     end
 
     it 'performs a conditional update when current-status is passed as a parameter' do
-      expect(@mock_resource).to receive(:[]).with('dor/objects/druid:123/workflows/etdSubmitWF/reader-approval?current-status=queued')
-      expect(@mock_resource).to receive(:put).with(@xml_re, { :content_type => 'application/xml' }).and_return('')
+      expect(mock_http_connection).to receive(:put).with("#{@repo}/objects/#{@druid}/workflows/etdSubmitWF/reader-approval?current-status=queued").and_call_original
+
       expect(Dor::WorkflowService.update_workflow_status(@repo, @druid, 'etdSubmitWF', 'reader-approval', 'completed', :version => 2, :note => 'annotation', :lane_id => 'lane1', :current_status => 'queued')).to be true
     end
+
+    it 'should throw exception if invalid status provided' do
+      expect { Dor::WorkflowService.update_workflow_status(@repo, @druid, 'accessionWF', 'publish', 'NOT_VALID_STATUS') }.to raise_error(ArgumentError)
+    end
   end
 
   describe '#update_workflow_error_status' do
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.put("#{@repo}/objects/#{@druid}/workflows/etdSubmitWF/reader-approval") do |env|
+          expect(env.body).to match /status="error" errorMessage="Some exception" errorText="The optional stacktrace"/
+          [201, {}, '']
+        end
+
+        stub.put("#{@repo}/objects/#{@druid}/workflows/errorWF/reader-approval") do |env|
+          [400, {}, '']
+        end
+      end
+    end
+
     it 'should update workflow status to error and return true if successful' do
-      expect(@mock_resource).to receive(:put).with(/status="error" errorMessage="Some exception" errorText="The optional stacktrace"/, { :content_type => 'application/xml' }).and_return('')
       Dor::WorkflowService.update_workflow_error_status(@repo, @druid, 'etdSubmitWF', 'reader-approval', 'Some exception', :error_text =>'The optional stacktrace')
     end
     it 'should return false if the PUT to the DOR workflow service throws an exception' do
-      ex = Exception.new('exception thrown')
-      expect(@mock_resource).to receive(:put).with(/status="completed"/, { :content_type => 'application/xml' }).and_raise(ex)
-      expect{ Dor::WorkflowService.update_workflow_status(@repo, @druid, 'etdSubmitWF', 'reader-approval', 'completed') }.to raise_error(Exception, 'exception thrown')
+      expect{ Dor::WorkflowService.update_workflow_status(@repo, @druid, 'errorWF', 'reader-approval', 'completed') }.to raise_error(Dor::WorkflowException, /status 400/)
     end
   end
 
   describe '#get_workflow_status' do
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.get("#{@repo}/objects/#{@druid}/workflows/etdSubmitWF") do |env|
+          [200, {}, '<process name="registrar-approval" status="completed" />']
+        end
+
+        stub.get("#{@repo}/objects/#{@druid}/workflows/missingWF") do |env|
+          [404, {}, '']
+        end
+
+        stub.get("#{@repo}/objects/#{@druid}/workflows/errorWF") do |env|
+          [200, {}, 'something not xml']
+        end
+
+        stub.get("#{@repo}/objects/#{@druid}/workflows/accessionWF") do |env|
+          [200, {}, '<process name="registrar-approval" status="completed" />']
+        end
+      end
+    end
+
     it 'parses workflow xml and returns status as a string' do
-      xml = '<process name="registrar-approval" status="completed" />'
-      allow(@mock_http_connection).to receive(:get).and_return(double Faraday::Response, :body => xml)
       expect(Dor::WorkflowService.get_workflow_status('dor', 'druid:123', 'etdSubmitWF', 'registrar-approval')).to eq('completed')
     end
     it 'should throw an exception if it fails for any reason' do
-      ex = Exception.new('exception thrown')
-      allow(@mock_http_connection).to receive(:get).and_raise(ex)
-      expect{ Dor::WorkflowService.get_workflow_status('dor', 'druid:123', 'etdSubmitWF', 'registrar-approval') }.to raise_error(Exception, 'exception thrown')
+      expect{ Dor::WorkflowService.get_workflow_status('dor', 'druid:123', 'missingWF', 'registrar-approval') }.to raise_error Dor::WorkflowException
     end
     it 'should throw an exception if it cannot parse the response' do
-      allow(@mock_http_connection).to receive(:get).and_return(double Faraday::Response, :body => 'something not xml')
-      expect{ Dor::WorkflowService.get_workflow_status('dor', 'druid:123', 'etdSubmitWF', 'registrar-approval') }.to raise_error(Exception, "Unable to parse response:\nsomething not xml")
+      expect{ Dor::WorkflowService.get_workflow_status('dor', 'druid:123', 'errorWF', 'registrar-approval') }.to raise_error(Dor::WorkflowException, "Unable to parse response:\nsomething not xml")
     end
     it 'should return nil if the workflow/process combination doesnt exist' do
-      allow(@mock_http_connection).to receive(:get).and_return(double Faraday::Response, :body => '<process name="registrar-approval" status="completed" />')
       expect(Dor::WorkflowService.get_workflow_status('dor', 'druid:123', 'accessionWF', 'publish')).to be_nil
     end
   end
 
   describe '#get_workflow_xml' do
+    let(:xml) { '<workflow id="etdSubmitWF"><process name="registrar-approval" status="completed" /></workflow>' }
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.get("dor/objects/druid:123/workflows/etdSubmitWF") do |env|
+          [200, {}, xml]
+        end
+      end
+    end
+
     it 'returns the xml for a given repository, druid, and workflow' do
-      xml = '<workflow id="etdSubmitWF"><process name="registrar-approval" status="completed" /></workflow>'
-      allow(@mock_http_connection).to receive(:get).and_return(double Faraday::Response, :body => xml)
       expect(Dor::WorkflowService.get_workflow_xml('dor', 'druid:123', 'etdSubmitWF')).to eq(xml)
     end
   end
 
+  describe '#get_workflows' do
+    let(:xml) { '<workflow id="accessionWF"><process name="publish" status="completed" /></workflow>' }
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.get("dor/objects/#{@druid}/workflows/") do |env|
+          [200, {}, xml]
+        end
+      end
+    end
+
+    it 'returns the workflows associated with druid' do
+      expect(Dor::WorkflowService.get_workflows(@druid)).to eq(['accessionWF'])
+    end
+  end
+
   describe '#get_lifecycle' do
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.get('dor/objects/druid:123/lifecycle') do |env|
+          [200, {}, <<-EOXML]
+            <lifecycle objectId="druid:ct011cv6501">
+                <milestone date="2010-04-27T11:34:17-0700">registered</milestone>
+                <milestone date="2010-04-29T10:12:51-0700">inprocess</milestone>
+                <milestone date="2010-06-15T16:08:58-0700">released</milestone>
+            </lifecycle>
+          EOXML
+        end
+
+        stub.get('dor/objects/druid:abc/lifecycle') do |env|
+          [200, {}, <<-EOXML]
+            <lifecycle />
+          EOXML
+        end
+      end
+    end
+
     it 'returns a Time object reprenting when the milestone was reached' do
-      xml = <<-EOXML
-        <lifecycle objectId="druid:ct011cv6501">
-            <milestone date="2010-04-27T11:34:17-0700">registered</milestone>
-            <milestone date="2010-04-29T10:12:51-0700">inprocess</milestone>
-            <milestone date="2010-06-15T16:08:58-0700">released</milestone>
-        </lifecycle>
-      EOXML
-      allow(@mock_http_connection).to receive(:get).and_return(double Faraday::Response, :body => xml)
       expect(Dor::WorkflowService.get_lifecycle('dor', 'druid:123', 'released').beginning_of_day).to eq(Time.parse('2010-06-15T16:08:58-0700').beginning_of_day)
     end
 
     it "returns nil if the milestone hasn't been reached yet" do
-      xml = '<lifecycle/>'
-      allow(@mock_http_connection).to receive(:get).and_return(double Faraday::Response, :body => xml)
       expect(Dor::WorkflowService.get_lifecycle('dor', 'druid:abc', 'inprocess')).to be_nil
     end
   end
 
+  describe '#get_active_lifecycle' do
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.get("dor/objects/#{@druid}/lifecycle") do |env|
+          [200, {}, <<-EOXML]
+            <lifecycle objectId="#{@druid}">
+                <milestone date="2010-04-27T11:34:17-0700">registered</milestone>
+                <milestone date="2010-04-29T10:12:51-0700">inprocess</milestone>
+                <milestone date="2010-06-15T16:08:58-0700">released</milestone>
+            </lifecycle>
+          EOXML
+        end
+
+        stub.get("dor/objects/#{@druid}/lifecycle") do |env|
+          [200, {}, <<-EOXML]
+            <lifecycle />
+          EOXML
+        end
+      end
+    end
+
+    it 'parses out the active lifecycle' do
+      expect(Dor::WorkflowService.get_active_lifecycle('dor', @druid, 'released').beginning_of_day).to eq(Time.parse('2010-06-15T16:08:58-0700').beginning_of_day)
+    end
+
+    it 'handles missing lifecycle' do
+      expect(Dor::WorkflowService.get_active_lifecycle('dor', @druid, 'NOT_FOUND')).to be_nil
+    end
+  end
+
   context '#get_objects_for_workstep' do
-    before :each do
+    before :all do
       @repository = 'dor'
       @workflow   = 'googleScannedBookWF'
       @completed  = 'google-download'
       @waiting    = 'process-content'
     end
 
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.get("workflow_queue?waiting=#{@repository}:#{@workflow}:#{@waiting}&completed=#{@repository}:#{@workflow}:#{@completed}&lane-id=default") do |env|
+          [200, {}, '<objects count="1"><object id="druid:ab123de4567"/><object id="druid:ab123de9012"/></objects>']
+        end
+      end
+    end
+
     describe 'a query with one step completed and one waiting' do
       it 'creates the URI string with only the one completed step' do
-        xml = %{<objects count="1"><object id="druid:ab123de4567"/><object id="druid:ab123de9012"/></objects>}
-        allow(@mock_http_connection).to receive(:get).with("workflow_queue?waiting=#{@repository}:#{@workflow}:#{@waiting}&completed=#{@repository}:#{@workflow}:#{@completed}&lane-id=default").and_return(double Faraday::Response, :body => xml)
         expect(Dor::WorkflowService.get_objects_for_workstep(@completed, @waiting, 'default', :default_repository => @repository, :default_workflow => @workflow)).to eq(['druid:ab123de4567', 'druid:ab123de9012'])
       end
     end
@@ -195,7 +315,7 @@ describe Dor::WorkflowService do
       it 'creates the URI string with the two completed steps correctly' do
         second_completed = 'google-convert'
         xml = %{<objects count="1"><object id="druid:ab123de4567"/><object id="druid:ab123de9012"/></objects>}
-        allow(@mock_http_connection).to receive(:get).with("workflow_queue?waiting=#{@repository}:#{@workflow}:#{@waiting}&completed=#{@repository}:#{@workflow}:#{@completed}&completed=#{@repository}:#{@workflow}:#{second_completed}&lane-id=default").and_return(double Faraday::Response, :body => xml)
+        allow(mock_http_connection).to receive(:get).with("workflow_queue?waiting=#{@repository}:#{@workflow}:#{@waiting}&completed=#{@repository}:#{@workflow}:#{@completed}&completed=#{@repository}:#{@workflow}:#{second_completed}&lane-id=default").and_return(double Faraday::Response, :body => xml)
         expect(Dor::WorkflowService.get_objects_for_workstep([@completed, second_completed], @waiting, 'default', :default_repository => @repository, :default_workflow => @workflow)).to eq(['druid:ab123de4567', 'druid:ab123de9012'])
       end
     end
@@ -211,7 +331,7 @@ describe Dor::WorkflowService do
           qualified_completed2 = "sdr:sdrIngestWF:complete-deposit"
           qualified_completed3 = "sdr:sdrIngestWF:ingest-transfer"
           xml = %{<objects count="2"><object id="druid:ab123de4567"/><object id="druid:ab123de9012"/></objects>}
-          allow(@mock_http_connection).to receive(:get).with("workflow_queue?waiting=#{@qualified_waiting}&completed=#{@qualified_completed}&completed=#{qualified_completed2}&completed=#{qualified_completed3}&lane-id=#{laneid}").and_return(double Faraday::Response, :body => xml)
+          allow(mock_http_connection).to receive(:get).with("workflow_queue?waiting=#{@qualified_waiting}&completed=#{@qualified_completed}&completed=#{qualified_completed2}&completed=#{qualified_completed3}&lane-id=#{laneid}").and_return(double Faraday::Response, :body => xml)
           args = [[@qualified_completed, qualified_completed2, qualified_completed3], @qualified_waiting]
           args << laneid if laneid != 'default'
           expect(Dor::WorkflowService.get_objects_for_workstep(*args)).to eq(['druid:ab123de4567', 'druid:ab123de9012'])
@@ -234,15 +354,15 @@ describe Dor::WorkflowService do
           @xml = %{<objects count="1"><object id="druid:ab123de4567"/></objects>}
         end
         it 'with only one completed step passed in as a String' do
-          allow(@mock_http_connection).to receive(:get).with("workflow_queue?waiting=#{@qualified_waiting}&completed=#{@qualified_completed}&lane-id=default").and_return(double Faraday::Response, :body => @xml)
+          allow(mock_http_connection).to receive(:get).with("workflow_queue?waiting=#{@qualified_waiting}&completed=#{@qualified_completed}&lane-id=default").and_return(double Faraday::Response, :body => @xml)
           expect(Dor::WorkflowService.get_objects_for_workstep(@qualified_completed, @qualified_waiting)).to eq(['druid:ab123de4567'])
         end
         it 'without any completed steps, only waiting' do
-          allow(@mock_http_connection).to receive(:get).with("workflow_queue?waiting=#{@qualified_waiting}&lane-id=default").and_return(double Faraday::Response, :body => @xml)
+          allow(mock_http_connection).to receive(:get).with("workflow_queue?waiting=#{@qualified_waiting}&lane-id=default").and_return(double Faraday::Response, :body => @xml)
           expect(Dor::WorkflowService.get_objects_for_workstep(nil, @qualified_waiting)).to eq(['druid:ab123de4567'])
         end
         it 'same but with lane_id' do
-          allow(@mock_http_connection).to receive(:get).with("workflow_queue?waiting=#{@qualified_waiting}&lane-id=lane1").and_return(double Faraday::Response, :body => @xml)
+          allow(mock_http_connection).to receive(:get).with("workflow_queue?waiting=#{@qualified_waiting}&lane-id=lane1").and_return(double Faraday::Response, :body => @xml)
           expect(Dor::WorkflowService.get_objects_for_workstep(nil, @qualified_waiting, 'lane1')).to eq([ 'druid:ab123de4567' ])
         end
       end
@@ -250,21 +370,110 @@ describe Dor::WorkflowService do
   end
 
   context 'get empty workflow queue' do
+    before(:all) do
+      @repository = 'dor'
+      @workflow   = 'googleScannedBookWF'
+      @completed  = 'google-download'
+      @waiting    = 'process-content'
+    end
+
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.get("workflow_queue?waiting=#{@repository}:#{@workflow}:#{@waiting}&completed=#{@repository}:#{@workflow}:#{@completed}&lane-id=default") do |env|
+          [200, {}, '<objects count="0"/>']
+        end
+      end
+    end
+
     it 'returns an empty list if it encounters an empty workflow queue' do
-      repository = 'dor'
-      workflow   = 'googleScannedBookWF'
-      completed  = 'google-download'
-      waiting    = 'process-content'
-      xml = %{<objects count="0"/>}
-      allow(@mock_http_connection).to receive(:get).with("workflow_queue?waiting=#{repository}:#{workflow}:#{waiting}&completed=#{repository}:#{workflow}:#{completed}&lane-id=default").and_return(double Faraday::Response, :body => xml)
-      expect(Dor::WorkflowService.get_objects_for_workstep(completed, waiting, 'default', :default_repository => repository, :default_workflow => workflow)).to eq([])
+      expect(Dor::WorkflowService.get_objects_for_workstep(@completed, @waiting, 'default', :default_repository => @repository, :default_workflow => @workflow)).to eq([])
+    end
+  end
+
+  context 'get errored workflow steps' do
+    before(:all) do
+      @repository = 'dor'
+      @workflow   = 'accessionWF'
+      @step       = 'publish'
+    end
+
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.get("/workflow_queue?error=#{@step}&repository=#{@repository}&workflow=#{@workflow}") do |env|
+          [200, {}, <<-EOXML ]
+            <objects count="1">
+               <object id="druid:ab123cd4567" errorMessage="This is an error message"/>
+             </objects>
+            EOXML
+        end
+      end
+    end
+    
+    it 'returns error messages for errored objects' do
+      expect(Dor::WorkflowService.get_errored_objects_for_workstep(@workflow, @step, @repository)).to eq({'druid:ab123cd4567'=>'This is an error message'})
+    end
+
+    it 'counts how many steps are errored out' do
+      expect(Dor::WorkflowService.count_errored_for_workstep(@workflow, @step, @repository)).to eq(1)
+    end
+  end
+
+  describe '#count_queued_for_workstep' do
+    before(:all) do
+      @repository = 'dor'
+      @workflow   = 'accessionWF'
+      @step       = 'publish'
+    end
+
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.get("/workflow_queue?queued=#{@step}&repository=#{@repository}&workflow=#{@workflow}") do |env|
+          [200, {}, <<-EOXML ]
+            <objects count="1">
+               <object id="druid:ab123cd4567"/>
+             </objects>
+            EOXML
+        end
+      end
+    end
+
+    it 'counts how many steps are errored out' do
+      expect(Dor::WorkflowService.count_queued_for_workstep(@workflow, @step, @repository)).to eq(1)
+    end
+  end
+
+  describe '#count_archived_for_workflow' do
+    before(:all) do
+      @repository = 'dor'
+      @workflow   = 'accessionWF'
+    end
+
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.get("/workflow_archive?repository=#{@repository}&workflow=#{@workflow}&count-only=true") do |env|
+          [200, {}, <<-EOXML ]
+            <objects count="20" />
+            EOXML
+        end
+      end
+    end
+
+    it 'counts how many workflows are archived' do
+      expect(Dor::WorkflowService.count_archived_for_workflow(@workflow, @repository)).to eq(20)
     end
   end
 
   describe '#delete_workflow' do
+    let(:url) { "#{@repo}/objects/#{@druid}/workflows/accessionWF" }
+
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.delete(url) { |env| [202, {}, ''] }
+      end
+    end
+
     it 'sends a delete request to the workflow service' do
-      expect(@mock_resource).to receive(:[]).with("#{@repo}/objects/#{@druid}/workflows/accessionWF")
-      expect(@mock_resource).to receive(:delete)
+      expect(mock_http_connection).to receive(:delete).with(url).and_call_original
       Dor::WorkflowService.delete_workflow(@repo, @druid, 'accessionWF')
     end
   end
@@ -298,28 +507,44 @@ describe Dor::WorkflowService do
   end
 
   describe '#close_version' do
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.post('dor/objects/druid:123/versionClose?create-accession=false') do |env|
+          [202, {}, '']
+        end
+
+        stub.post('dor/objects/druid:123/versionClose') do |env|
+          [202, {}, '']
+        end
+      end
+    end
+
+    let(:url) { 'dor/objects/druid:123/versionClose' }
     it 'calls the versionClose endpoint with druid' do
-      expect(@mock_resource).to receive(:[]).with('dor/objects/druid:123/versionClose').and_return(@mock_resource)
-      expect(@mock_resource).to receive(:post).with('').and_return('')
       Dor::WorkflowService.close_version(@repo, @druid)
     end
 
     it 'optionally prevents creation of accessionWF' do
-      expect(@mock_resource).to receive(:[]).with('dor/objects/druid:123/versionClose?create-accession=false').and_return(@mock_resource)
-      expect(@mock_resource).to receive(:post).with('').and_return('')
+      expect(mock_http_connection).to receive(:post).with('dor/objects/druid:123/versionClose?create-accession=false').and_call_original
       Dor::WorkflowService.close_version(@repo, @druid, false)
     end
   end
 
   describe '.get_stale_queued_workflows' do
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.get('workflow_queue/all_queued?repository=dor&hours-ago=24&limit=100') do |env|
+          [200, {}, <<-XML]
+          <workflows>
+              <workflow laneId="lane1" note="annotation" lifecycle="in-process" errorText="stacktrace" errorMessage="NullPointerException" elapsed="1.173" repository="dor" attempts="0" datetime="2008-11-15T13:30:00-0800" status="waiting" process="content-metadata" name="accessionWF" druid="dr:123"/>
+              <workflow laneId="lane2" note="annotation" lifecycle="in-process" errorText="stacktrace" errorMessage="NullPointerException" elapsed="1.173" repository="dor" attempts="0" datetime="2008-11-15T13:30:00-0800" status="waiting" process="jp2-create" name="assemblyWF" druid="dr:456"/>
+          </workflows>
+          XML
+        end
+      end
+    end
+
     it 'returns an Array of Hashes containing each workflow step' do
-      xml = <<-XML
-        <workflows>
-            <workflow laneId="lane1" note="annotation" lifecycle="in-process" errorText="stacktrace" errorMessage="NullPointerException" elapsed="1.173" repository="dor" attempts="0" datetime="2008-11-15T13:30:00-0800" status="waiting" process="content-metadata" name="accessionWF" druid="dr:123"/>
-            <workflow laneId="lane2" note="annotation" lifecycle="in-process" errorText="stacktrace" errorMessage="NullPointerException" elapsed="1.173" repository="dor" attempts="0" datetime="2008-11-15T13:30:00-0800" status="waiting" process="jp2-create" name="assemblyWF" druid="dr:456"/>
-        </workflows>
-      XML
-      allow(@mock_http_connection).to receive(:get).with('workflow_queue/all_queued?repository=dor&hours-ago=24&limit=100').and_return(double Faraday::Response, :body => xml)
       ah = Dor::WorkflowService.get_stale_queued_workflows 'dor', :hours_ago => 24, :limit => 100
       expected = [
         { :workflow => 'accessionWF', :step => 'content-metadata', :druid => 'dr:123', :lane_id => 'lane1' },
@@ -330,46 +555,35 @@ describe Dor::WorkflowService do
   end
 
   describe '.count_stale_queued_workflows' do
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.get('workflow_queue/all_queued?repository=dor&hours-ago=48&count-only=true') do |env|
+          [200, {}, '<objects count="10"/>']
+        end
+      end
+    end
+
     it 'returns the number of queued workflow steps' do
-      xml = %{<objects count="10"/>}
-      allow(@mock_http_connection).to receive(:get).with('workflow_queue/all_queued?repository=dor&hours-ago=48&count-only=true').and_return(double Faraday::Response, :body => xml)
       expect(Dor::WorkflowService.count_stale_queued_workflows('dor', :hours_ago => 48)).to eq(10)
     end
   end
 
   describe '.get_lane_ids' do
-    it 'returns the lane ids for a given workflow step' do
-      xml = <<-XML
-      <lanes>
-        <lane id="lane1"/>
-        <lane id="lane2"/>
-      </lanes>
-      XML
-      allow(@mock_http_connection).to receive(:get).with('workflow_queue/lane_ids?step=dor:accessionWF:shelve').and_return(double Faraday::Response, :body => xml)
-      expect(Dor::WorkflowService.get_lane_ids('dor', 'accessionWF', 'shelve')).to eq(%w(lane1 lane2))
-    end
-  end
-
-  describe 'protected method' do
-    describe '#build_queued_uri' do
-      it 'does something' do
-        skip 'test unimplemented'
-      end
-    end
-    describe '#parse_queued_workflows_response' do
-      it 'does something' do
-        skip 'test unimplemented'
-      end
-    end
-    describe '#add_lane_id_to_workflow_xml' do
-      it 'does something' do
-        skip 'test unimplemented'
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.get('workflow_queue/lane_ids?lane_ids?step=dor:accessionWF:shelve') do |env|
+          [200, {}, <<-XML]
+          <lanes>
+            <lane id="lane1"/>
+            <lane id="lane2"/>
+          </lanes>
+          XML
+        end
       end
     end
-    describe '#count_objects_in_step' do
-      it 'does something' do
-        skip 'test unimplemented'
-      end
+
+    it 'returns the lane ids for a given workflow step' do
+      expect(Dor::WorkflowService.get_lane_ids('dor', 'accessionWF', 'shelve')).to eq(%w(lane1 lane2))
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dor-workflow-service
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Willy Mene
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-02 00:00:00.000000000 Z
+date: 2016-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -45,20 +45,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.6.0
-- !ruby/object:Gem::Dependency
-  name: rest-client
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.7'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: retries
   requirement: !ruby/object:Gem::Requirement
@@ -191,6 +177,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.5.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Enables Ruby manipulation of the DOR Workflow Service via its REST API
 email:
 - wmene@stanford.edu
@@ -215,6 +215,7 @@ files:
 - gemfiles/rails4.gemfile
 - lib/dor-workflow-service.rb
 - lib/dor/services/workflow_service.rb
+- lib/dor/workflow_exception.rb
 - lib/dor/workflow_version.rb
 - spec/plumbing_spec.rb
 - spec/spec_helper.rb
@@ -238,7 +239,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Provides convenience methods to work with the DOR Workflow Service
@@ -246,3 +247,4 @@ test_files:
 - spec/plumbing_spec.rb
 - spec/spec_helper.rb
 - spec/workflow_service_spec.rb
+has_rdoc: