stash-merritt 0.0.1

data/spec/rspec_custom_matchers.rb

@@ -0,0 +1,92 @@
+require 'rspec/expectations'
+require 'equivalent-xml'
+require 'diffy'
+
+module Stash
+  module XMLMatchUtils
+    def self.to_nokogiri(xml)
+      return nil unless xml
+      case xml
+      when Nokogiri::XML::Element
+        xml
+      when Nokogiri::XML::Document
+        xml.root
+      when String
+        to_nokogiri(Nokogiri::XML(xml, &:noblanks))
+      when REXML::Element
+        to_nokogiri(xml.to_s)
+      else
+        raise "be_xml() expected XML, got #{xml.class}"
+      end
+    end
+
+    def self.to_pretty(nokogiri)
+      return nil unless nokogiri
+      out = StringIO.new
+      save_options = Nokogiri::XML::Node::SaveOptions::FORMAT | Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+      nokogiri.write_xml_to(out, encoding: 'UTF-8', indent: 2, save_with: save_options)
+      out.string
+    end
+
+    def self.equivalent?(expected, actual, filename = nil)
+      expected_xml = to_nokogiri(expected) || raise("expected value #{expected || 'nil'} does not appear to be XML#{" in #{filename}" if filename}")
+      actual_xml = to_nokogiri(actual)
+
+      EquivalentXml.equivalent?(expected_xml, actual_xml, element_order: false, normalize_whitespace: true)
+    end
+
+    def self.failure_message(expected, actual, filename = nil)
+      expected_string = to_pretty(to_nokogiri(expected))
+      actual_string = to_pretty(to_nokogiri(actual)) || actual
+
+      now = Time.now.to_i
+      FileUtils.mkdir('tmp') unless File.directory?('tmp')
+      File.open("tmp/#{now}-expected.xml", 'w') { |f| f.write(expected_string) }
+      File.open("tmp/#{now}-actual.xml", 'w') { |f| f.write(actual_string) }
+
+      diff = Diffy::Diff.new(expected_string, actual_string).to_s(:text)
+
+      "expected XML differs from actual#{" in #{filename}" if filename}:\n#{diff}"
+    end
+
+    def self.to_xml_string(actual)
+      to_pretty(to_nokogiri(actual))
+    end
+
+    def self.failure_message_when_negated(actual, filename = nil)
+      "expected not to get XML#{" in #{filename}" if filename}:\n\t#{to_xml_string(actual) || 'nil'}"
+    end
+  end
+end
+
+RSpec::Matchers.define :be_xml do |expected, filename = nil|
+  match do |actual|
+    Stash::XMLMatchUtils.equivalent?(expected, actual, filename)
+  end
+
+  failure_message do |actual|
+    Stash::XMLMatchUtils.failure_message(expected, actual, filename)
+  end
+
+  failure_message_when_negated do |actual|
+    Stash::XMLMatchUtils.failure_message_when_negated(actual, filename)
+  end
+end
+
+RSpec::Matchers.define :be_time do |expected|
+  def to_string(time)
+    time.is_a?(Time) ? time.utc.round(2).iso8601(2) : time.to_s
+  end
+
+  match do |actual|
+    return actual.nil? unless expected
+    raise "Expected value #{expected} is not a Time" unless expected.is_a?(Time)
+    actual.is_a?(Time) && (to_string(expected) == to_string(actual))
+  end
+
+  failure_message do |actual|
+    expected_str = to_string(expected)
+    actual_str = to_string(actual)
+    "expected time:\n#{expected_str}\n\nbut was:\n#{actual_str}"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,86 @@
+# ------------------------------------------------------------
+# SimpleCov setup
+
+if ENV['COVERAGE']
+  require 'simplecov'
+  require 'simplecov-console'
+
+  SimpleCov.minimum_coverage 100
+  SimpleCov.start do
+    add_filter '/spec/'
+    SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+      SimpleCov::Formatter::HTMLFormatter,
+      SimpleCov::Formatter::Console,
+    ]
+  end
+end
+
+# ------------------------------------------------------------
+# Rspec configuration
+
+RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
+  config.mock_with :rspec
+end
+
+require 'rspec_custom_matchers'
+
+# ------------------------------------------------------------
+# ActiveRecord
+
+require 'active_record'
+# Note: Even if we're not doing any database work, ActiveRecord callbacks will still raise warnings
+ActiveRecord::Base.raise_in_transactional_callbacks = true
+
+# ------------------------------------------------------------
+# StashEngine
+
+ENV['STASH_ENV'] = 'test'
+ENV['RAILS_ENV'] = 'test'
+
+::LICENSES = YAML.load_file('spec/config/licenses.yml').with_indifferent_access
+::APP_CONFIG = OpenStruct.new(YAML.load_file('spec/config/app_config.yml')['test'])
+
+stash_engine_path = Gem::Specification.find_by_name('stash_engine').gem_dir
+require "#{stash_engine_path}/config/initializers/hash_to_ostruct.rb"
+
+require 'stash_engine'
+
+%w(
+  app/models/stash_engine
+  app/mailers
+  app/mailers/stash_engine
+  app/jobs/stash_engine
+  lib/stash_engine
+).each do |dir|
+  Dir.glob("#{stash_engine_path}/#{dir}/**/*.rb").sort.each(&method(:require))
+end
+
+# ------------------------------------------------------------
+# StashDatacite
+
+module StashDatacite
+  @@resource_class = 'StashEngine::Resource' # rubocop:disable Style/ClassVars
+end
+
+require 'stash_datacite'
+
+# TODO: do we need all of these?
+stash_datacite_path = Gem::Specification.find_by_name('stash_datacite').gem_dir
+%w(
+  app/models/stash_datacite
+  app/models/stash_datacite/resource
+  lib/stash_datacite
+  lib
+).each do |dir|
+  Dir.glob("#{stash_datacite_path}/#{dir}/**/*.rb").sort.each(&method(:require))
+end
+
+StashDatacite::ResourcePatch.associate_with_resource(StashEngine::Resource)
+
+require 'util/resource_builder'
+
+# ------------------------------------------------------------
+# Stash::Merritt
+
+require 'stash/merritt'

data/spec/unit/stash/merritt/ezid_helper_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'ostruct'
+
+module Stash
+  module Merritt
+    describe EzidHelper do
+      attr_reader :resource_id
+      attr_reader :resource
+      attr_reader :identifier_str
+      attr_reader :landing_page_url
+      attr_reader :helper
+      attr_reader :url_helpers
+      attr_reader :tenant
+
+      before(:each) do
+        @resource_id = 17
+        @resource = double(StashEngine::Resource)
+        allow(StashEngine::Resource).to receive(:find).with(resource_id).and_return(resource)
+
+        @identifier_str = 'doi:10.15146/R38675309'
+        @url_helpers = double(Module)
+        @landing_page_url = "http://stash.example.edu/stash/#{identifier_str}"
+        allow(url_helpers).to receive(:show_path).with(identifier_str).and_return(landing_page_url)
+
+        @tenant = double(StashEngine::Tenant)
+        id_params = {
+          shoulder: 'doi:10.15146/R3',
+          owner: 'stash_admin',
+          account: 'stash',
+          password: '3cc9d3fbd9788148c6a32a1415fa673a',
+          id_scheme: 'doi'
+        }
+        allow(tenant).to receive(:identifier_service).and_return(OpenStruct.new(id_params))
+        allow(tenant).to receive(:tenant_id).and_return('dataone')
+        allow(resource).to receive(:tenant).and_return(tenant)
+
+        @helper = EzidHelper.new(resource: resource, url_helpers: url_helpers)
+      end
+
+      describe :ensure_identifier do
+        it 'returns an existing identifier without bothering EZID' do
+          expect(resource).to receive(:identifier_str).and_return(identifier_str)
+          expect(::Ezid::Client).not_to receive(:new)
+          expect(helper.ensure_identifier).to eq(identifier_str)
+        end
+
+        it 'mints and assigns a new identifier if none is present' do
+          identifier = instance_double(::Ezid::MintIdentifierResponse)
+          allow(identifier).to receive(:id).and_return(identifier_str)
+
+          ezid_client = instance_double(::Ezid::Client)
+          allow(::Ezid::Client).to receive(:new)
+            .with(user: 'stash', password: '3cc9d3fbd9788148c6a32a1415fa673a')
+            .and_return(ezid_client)
+
+          expect(resource).to receive(:identifier_str).and_return(nil)
+          expect(ezid_client).to receive(:mint_identifier)
+            .with('doi:10.15146/R3', status: 'reserved', profile: 'datacite')
+            .and_return(identifier)
+          expect(resource).to receive(:ensure_identifier).with(identifier_str)
+          expect(helper.ensure_identifier).to eq(identifier_str)
+        end
+      end
+
+      describe :update_metadata do
+        it 'updates the metadata and landing page' do
+          dc3_xml = '<resource/>'
+
+          ezid_client = instance_double(::Ezid::Client)
+          allow(::Ezid::Client).to receive(:new)
+            .with(user: 'stash', password: '3cc9d3fbd9788148c6a32a1415fa673a')
+            .and_return(ezid_client)
+
+          expect(ezid_client).to receive(:modify_identifier).with(
+            identifier_str,
+            datacite: dc3_xml,
+            target: landing_page_url,
+            status: 'public',
+            owner: 'stash_admin'
+          )
+
+          expect(resource).to receive(:identifier_str).and_return(identifier_str)
+          helper.update_metadata(dc3_xml: dc3_xml)
+        end
+      end
+    end
+  end
+end

data/spec/unit/stash/merritt/repository_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Stash
+  module Merritt
+    describe Repository do
+      describe :create_submission_job do
+        it 'creates a submission job' do
+          url_helpers = double(Module) # yes, apparently URL helpers are an anonymous module
+          repo = Repository.new(url_helpers: url_helpers)
+          resource_id = 17
+          job = repo.create_submission_job(resource_id: resource_id)
+          expect(job).to be_a(SubmissionJob)
+          expect(job.resource_id).to eq(resource_id)
+          expect(job.url_helpers).to be(url_helpers)
+        end
+      end
+    end
+  end
+end

data/spec/unit/stash/merritt/submission_job_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+module Stash
+  module Merritt
+    describe SubmissionJob do
+      attr_reader :logger
+      attr_reader :tenant
+      attr_reader :resource_id
+      attr_reader :resource
+      attr_reader :url_helpers
+      attr_reader :ezid_helper
+      attr_reader :package
+      attr_reader :sword_helper
+      attr_reader :job
+
+      before(:each) do
+        @logger = instance_double(Logger)
+        allow(logger).to receive(:debug) { |msg| puts "debug: #{msg}" }
+        allow(logger).to receive(:info) { |msg| puts "info: #{msg}" }
+        allow(logger).to receive(:warn) { |msg| puts "warn: #{msg}" }
+        allow(logger).to receive(:error) { |msg| puts "error: #{msg}" }
+
+        @rails_logger = Rails.logger
+        Rails.logger = logger
+
+        @tenant = double(StashEngine::Tenant)
+        sword_params = {
+          collection_uri: 'http://example.edu/sword/example',
+          username: 'elvis',
+          password: 'presley'
+        }.freeze
+        allow(tenant).to receive(:sword_params).and_return(sword_params)
+        allow(tenant).to receive(:id).and_return('example_u')
+
+        @resource_id = 37
+        @resource = double(StashEngine::Resource)
+        allow(StashEngine::Resource).to receive(:find).with(resource_id).and_return(resource)
+        allow(resource).to receive(:identifier_str).and_return('doi:10.123/456')
+        allow(resource).to receive(:update_uri).and_return(nil)
+        allow(resource).to receive(:tenant).and_return(tenant)
+        allow(resource).to receive(:tenant_id).and_return('example_u')
+
+        @url_helpers = double(Module) # yes, apparently URL helpers are an anonymous module
+        allow(url_helpers).to(receive(:show_path)) { |identifier| identifier }
+
+        @ezid_helper = instance_double(EzidHelper)
+        allow(EzidHelper).to receive(:new).with(resource: resource, url_helpers: url_helpers).and_return(ezid_helper)
+        allow(ezid_helper).to receive(:ensure_identifier)
+        allow(ezid_helper).to receive(:update_metadata)
+
+        @package = instance_double(SubmissionPackage)
+        allow(SubmissionPackage).to receive(:new).with(resource: resource).and_return(package)
+        allow(package).to receive(:dc3_xml)
+        allow(package).to receive(:cleanup!)
+
+        @sword_helper = instance_double(SwordHelper)
+        allow(SwordHelper).to receive(:new).with(package: package, logger: logger).and_return(sword_helper)
+        allow(sword_helper).to receive(:submit!)
+
+        @job = SubmissionJob.new(resource_id: resource_id, url_helpers: url_helpers)
+      end
+
+      after(:each) do
+        Rails.logger = @rails_logger
+      end
+
+      describe :submit! do
+        it 'ensures an identifier' do
+          expect(ezid_helper).to receive(:ensure_identifier)
+          job.submit!
+        end
+
+        it 'submits the package' do
+          expect(sword_helper).to receive(:submit!)
+          job.submit!
+        end
+
+        it 'updates the metadata' do
+          dc3_xml = '<resource/>'
+          expect(package).to receive(:dc3_xml).and_return(dc3_xml)
+          expect(ezid_helper).to receive(:update_metadata).with(dc3_xml: dc3_xml)
+          job.submit!
+        end
+
+        it 'cleans up the package' do
+          expect(package).to receive(:cleanup!)
+          job.submit!
+        end
+
+        it 'returns a result' do
+          result = job.submit!
+          expect(result).to be_a(Stash::Repo::SubmissionResult)
+          expect(result.success?).to be_truthy
+        end
+
+        describe 'error handling' do
+          it 'fails on a bad resource ID' do
+            bad_id = resource_id * 17
+            job = SubmissionJob.new(resource_id: bad_id, url_helpers: url_helpers)
+            allow(StashEngine::Resource).to receive(:find).with(bad_id).and_raise(ActiveRecord::RecordNotFound)
+            expect(job.submit!.error).to be_a(ActiveRecord::RecordNotFound)
+          end
+
+          it 'fails on an ID minting error' do
+            expect(ezid_helper).to receive(:ensure_identifier).and_raise(Ezid::NotAllowedError)
+            expect(job.submit!.error).to be_a(Ezid::NotAllowedError)
+          end
+
+          it 'fails on a SWORD submission error' do
+            expect(sword_helper).to receive(:submit!).and_raise(RestClient::RequestFailed)
+            expect(job.submit!.error).to be_a(RestClient::RequestFailed)
+          end
+
+          it 'fails on a metadata update error' do
+            expect(ezid_helper).to receive(:update_metadata).and_raise(Ezid::IdentifierNotFoundError)
+            expect(job.submit!.error).to be_a(Ezid::IdentifierNotFoundError)
+          end
+
+          it 'fails on a package cleanup error' do
+            expect(package).to receive(:cleanup!).and_raise(Errno::ENOENT)
+            expect(job.submit!.error).to be_a(Errno::ENOENT)
+          end
+        end
+      end
+    end
+  end
+end