hyrax 3.0.0.pre.beta2 → 3.0.0.pre.beta3

data/spec/services/hyrax/embargo_manager_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+RSpec.describe Hyrax::EmbargoManager do
+  subject(:manager) { described_class.new(resource: resource) }
+  let(:resource)    { Hyrax::Resource.new }
+
+  shared_context 'when under embargo' do
+    let(:resource) { FactoryBot.build(:hyrax_resource, :under_embargo) }
+  end
+
+  shared_context 'with expired embargo' do
+    let(:resource) { FactoryBot.build(:hyrax_resource, embargo: embargo) }
+    let(:embargo)  { FactoryBot.build(:hyrax_embargo, :expired) }
+  end
+
+  describe '#apply' do
+    context 'with no embargo' do
+      it 'is a no-op' do
+        expect { manager.apply }
+          .not_to change { resource.visibility }
+      end
+    end
+
+    context 'with expried embargo' do
+      include_context 'with expired embargo'
+
+      it 'is a no-op' do
+        expect { manager.apply }
+          .not_to change { resource.visibility }
+      end
+    end
+
+    context 'when under embargo' do
+      include_context 'when under embargo'
+
+      before { resource.visibility = 'open' }
+
+      it 'applies the active embargo visibility' do
+        expect { manager.apply }
+          .to change { resource.visibility }
+          .to 'authenticated'
+      end
+    end
+  end
+
+  describe '#copy_embargo_to' do
+    let(:other_resource) { Hyrax::Resource.new }
+
+    it 'does not assign an embargo when none is present' do
+      expect { manager.copy_embargo_to(target: other_resource) }
+        .not_to change { other_resource.embargo }
+        .from nil
+    end
+
+    context 'with expried embargo' do
+      include_context 'with expired embargo'
+
+      it 'does not copy the embargo' do
+        expect { manager.copy_embargo_to(target: other_resource) }
+          .not_to change { other_resource.embargo }
+          .from nil
+      end
+    end
+
+    context 'when under embargo' do
+      include_context 'when under embargo'
+
+      before { other_resource.visibility = 'open' }
+
+      it 'copies the embargo to the target' do
+        expect { manager.copy_embargo_to(target: other_resource) }
+          .to change { other_resource.embargo }
+          .from(nil)
+          .to have_attributes(embargo_release_date:
+                                manager.embargo.embargo_release_date)
+      end
+
+      it 'applies the active embargo visibility' do
+        expect { manager.copy_embargo_to(target: other_resource) }
+          .to change { other_resource.visibility }
+          .to 'authenticated'
+      end
+    end
+  end
+
+  describe '#embargo' do
+    it 'gives an inactive embargo' do
+      expect(manager.embargo).not_to be_active
+    end
+
+    context 'when under embargo' do
+      include_context 'when under embargo'
+
+      it 'gives an active embargo' do
+        expect(manager.embargo).to be_active
+      end
+
+      it 'has embargo attributes' do
+        expect(manager.embargo)
+          .to have_attributes visibility_after_embargo: 'open',
+                              visibility_during_embargo: 'authenticated',
+                              embargo_release_date: an_instance_of(Date),
+                              embargo_history: be_empty
+      end
+    end
+  end
+
+  describe '#under_embargo?' do
+    it { is_expected.not_to be_under_embargo }
+
+    context 'when under embargo' do
+      include_context 'when under embargo'
+
+      it { is_expected.to be_under_embargo }
+    end
+
+    context 'with expired embargo' do
+      include_context 'with expired embargo'
+
+      it { is_expected.not_to be_under_embargo }
+    end
+  end
+end

data/spec/services/hyrax/embargo_service_spec.rb

@@ -43,8 +43,8 @@ RSpec.describe Hyrax::EmbargoService do
     end
 
     before do
-      ActiveFedora::SolrService.add(attributes)
-      ActiveFedora::SolrService.commit
+      Hyrax::SolrService.add(attributes)
+      Hyrax::SolrService.commit
     end
 
     it 'returns all assets with embargo history set' do

data/spec/services/hyrax/file_set_visibility_propagator_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+RSpec.describe Hyrax::FileSetVisibilityPropagator do
+  subject(:propagator) { described_class.new(source: work) }
+  let(:work)           { FactoryBot.create(:work_with_files) }
+
+  context 'a public work' do
+    before do
+      work.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+    end
+
+    it 'copies visibility to its contained files' do
+      # files are private at the outset
+      expect(work.file_sets.first.visibility)
+        .to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
+
+      propagator.propagate
+
+      work.reload.file_sets.each do |file|
+        expect(file.visibility)
+          .to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+      end
+    end
+  end
+
+  context 'when work is under embargo' do
+    let(:work) { create(:embargoed_work_with_files) }
+    let(:file) { work.file_sets.first }
+
+    it 'copies visibility to its contained files and apply a copy of the embargo to the files' do
+      expect(work.visibility)
+        .to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
+      expect(work).to be_under_embargo
+      expect(work.file_sets.first).not_to be_under_embargo
+
+      propagator.propagate
+
+      expect(file).to be_under_embargo
+      expect(file.embargo.id).not_to eq work.embargo.id
+    end
+  end
+
+  context 'when work is under lease' do
+    let(:work) { create(:leased_work_with_files) }
+    let(:file) { work.file_sets.first }
+
+    it 'copies visibility to its contained files and apply a copy of the lease to the files' do
+      expect(work.visibility)
+        .to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+      expect(work).to be_active_lease
+      expect(work.file_sets.first).not_to be_active_lease
+
+      propagator.propagate
+
+      expect(file).to be_active_lease
+      expect(file.lease.id).not_to eq work.lease.id
+    end
+  end
+end

data/spec/services/hyrax/resource_visibility_propagator_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+RSpec.describe Hyrax::ResourceVisibilityPropagator do
+  subject(:propagator) { described_class.new(source: work) }
+  let(:queries)        { Hyrax.query_service.custom_queries }
+  let(:work)           { FactoryBot.create(:work_with_files).valkyrie_resource }
+  let(:file_sets)      { queries.find_child_filesets(resource: work) }
+
+  context 'a public work' do
+    before { work.visibility = 'open' }
+
+    it 'updates the file_set permissions' do
+      # files are private at the outset
+      expect(file_sets.first.visibility).to eq 'restricted'
+
+      expect { propagator.propagate }
+        .to change { queries.find_child_filesets(resource: work).map(&:visibility) }
+        .to contain_exactly(work.visibility, work.visibility)
+    end
+  end
+
+  context 'when work is under embargo' do
+    let(:work) { FactoryBot.create(:embargoed_work_with_files).valkyrie_resource }
+
+    before do
+      fs = file_sets.first
+      fs.visibility = 'open'
+      Hyrax.persister.save(resource: fs)
+    end
+
+    it 'copies visibility' do
+      expect { propagator.propagate }
+        .to change { queries.find_child_filesets(resource: work).map(&:visibility) }
+        .to contain_exactly(work.visibility, work.visibility)
+    end
+
+    it 'applies a copy of the embargo' do
+      release_date = work.embargo.embargo_release_date
+
+      expect { propagator.propagate }
+        .to change { queries.find_child_filesets(resource: work).map(&:embargo) }
+        .to contain_exactly(have_attributes(embargo_release_date: release_date),
+                            have_attributes(embargo_release_date: release_date))
+    end
+  end
+
+  context 'when work is under lease' do
+    let(:work) { FactoryBot.create(:leased_work_with_files).valkyrie_resource }
+
+    before do
+      fs = file_sets.first
+      fs.visibility = 'restricted'
+      Hyrax.persister.save(resource: fs)
+    end
+
+    it 'copies visibility' do
+      expect { propagator.propagate }
+        .to change { queries.find_child_filesets(resource: work).map(&:visibility) }
+        .to contain_exactly(work.visibility, work.visibility)
+    end
+
+    it 'applies a copy of the embargo' do
+      release_date = work.lease.lease_expiration_date
+
+      expect { propagator.propagate }
+        .to change { queries.find_child_filesets(resource: work).map(&:lease) }
+        .to contain_exactly(have_attributes(lease_expiration_date: release_date),
+                            have_attributes(lease_expiration_date: release_date))
+    end
+  end
+end

data/spec/services/hyrax/solr_query_builder_service_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::SolrQueryBuilderService do
+  describe '#construct_query_for_ids' do
+    it "generates a useable solr query from an array of Fedora ids" do
+      expect(described_class.construct_query_for_ids(["my:_ID1_", "my:_ID2_", "my:_ID3_"])).to eq '{!terms f=id}my:_ID1_,my:_ID2_,my:_ID3_'
+    end
+    it "returns a valid solr query even if given an empty array as input" do
+      expect(described_class.construct_query_for_ids([""])).to eq "id:NEVER_USE_THIS_ID"
+    end
+  end
+  describe "construct_query" do
+    it "generates a query clause" do
+      expect(described_class.construct_query('id' => "my:_ID1_")).to eq '_query_:"{!field f=id}my:_ID1_"'
+    end
+  end
+end

data/spec/services/hyrax/solr_service_spec.rb

@@ -0,0 +1,218 @@
+RSpec.describe Hyrax::SolrService do
+  let(:mock_conn) { instance_double(RSolr::Client) }
+
+  describe '.select_path' do
+    it 'raises NotImplementedError' do
+      expect { described_class.select_path }.to raise_error NotImplementedError
+    end
+  end
+
+  describe "#get" do
+    it "calls solr" do
+      stub_result = double("Result")
+      expect(mock_conn).to receive(:get).with('select', params: { q: 'querytext', qt: 'standard' }).and_return(stub_result)
+      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
+      expect(described_class.get('querytext')).to eq stub_result
+    end
+
+    it "uses args as params" do
+      stub_result = double("Result")
+      expect(mock_conn).to receive(:get).with('select', params: { fq: ["id:\"1234\""], q: 'querytext', qt: 'standard' }).and_return(stub_result)
+      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
+      expect(described_class.get('querytext', fq: ["id:\"1234\""])).to eq stub_result
+    end
+
+    it "uses the valkyrie solr core" do
+      service = described_class.new
+      stub_result = double("Valkyrie Result")
+      expect(mock_conn).to receive(:get).with('select', params: { q: 'querytext' }).and_return(stub_result)
+      allow(service).to receive(:valkyrie_index).and_return(double("valkyrie_index", connection: mock_conn))
+      expect(service.get('querytext', use_valkyrie: true)).to eq stub_result
+    end
+  end
+
+  describe "#post" do
+    it "calls solr" do
+      stub_result = double("Result")
+      expect(mock_conn).to receive(:post).with('select', data: { q: 'querytext', qt: 'standard' }).and_return(stub_result)
+      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
+      expect(described_class.post('querytext')).to eq stub_result
+    end
+
+    it "uses args as data" do
+      stub_result = double("Result")
+      expect(mock_conn).to receive(:post).with('select', data: { fq: ["id:\"1234\""], q: 'querytext', qt: 'standard' }).and_return(stub_result)
+      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
+      expect(described_class.post('querytext', fq: ["id:\"1234\""])).to eq stub_result
+    end
+
+    it "uses the valkyrie solr core" do
+      service = described_class.new
+      stub_result = double("Valkyrie Result")
+      expect(mock_conn).to receive(:post).with('select', data: { q: 'querytext' }).and_return(stub_result)
+      allow(service).to receive(:valkyrie_index).and_return(double("valkyrie_index", connection: mock_conn))
+      expect(service.post('querytext', use_valkyrie: true)).to eq stub_result
+    end
+  end
+
+  describe "#query" do
+    let(:doc) { { 'id' => 'x' } }
+    let(:docs) { [doc] }
+    let(:stub_result) { { 'response' => { 'docs' => docs } } }
+
+    before do
+      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
+    end
+
+    it "defaults to HTTP GET method" do
+      expect(mock_conn).to receive(:get).with('select', params: { rows: 2, q: 'querytext', qt: 'standard' }).and_return(stub_result)
+      described_class.query('querytext', rows: 2)
+    end
+
+    it "allows callers to specify HTTP POST method" do
+      expect(mock_conn).to receive(:post).with('select', data: { rows: 2, q: 'querytext', qt: 'standard' }).and_return(stub_result)
+      described_class.query('querytext', rows: 2, method: :post)
+    end
+
+    it "raises if method not GET or POST" do
+      expect(mock_conn).not_to receive(:head).with('select', data: { rows: 2, q: 'querytext', qt: 'standard' })
+      expect do
+        described_class.query('querytext', rows: 2, method: :head)
+      end.to raise_error(RuntimeError, "Unsupported HTTP method for querying SolrService (:head)")
+    end
+
+    it "wraps the solr response documents in Solr hits" do
+      expect(mock_conn).to receive(:get).with('select', params: { rows: 2, q: 'querytext', qt: 'standard' }).and_return(stub_result)
+      result = described_class.query('querytext', rows: 2)
+      expect(result.size).to eq 1
+      expect(result.first.id).to eq 'x'
+    end
+
+    it "warns about not passing rows" do
+      allow(mock_conn).to receive(:get).and_return(stub_result)
+      expect(Rails.logger).to receive(:warn).with(/^Calling Hyrax::SolrService\.get without passing an explicit value for ':rows' is not recommended/)
+      described_class.query('querytext')
+    end
+
+    context "when use_valkyrie: true" do
+      let(:doc) { { 'id' => 'valkyrie-x' } }
+
+      it "accepts and passes through use_valkyrie:true" do
+        service = described_class.new
+        expect(mock_conn).to receive(:get).with('select', params: { q: 'querytext' }).and_return(stub_result)
+        allow(service).to receive(:valkyrie_index).and_return(double("valkyrie_index", connection: mock_conn))
+        result = service.query('querytext', use_valkyrie: true)
+        expect(result.first.id).to eq 'valkyrie-x'
+      end
+    end
+  end
+
+  describe ".commit" do
+    it "calls solr" do
+      expect(mock_conn).to receive(:commit)
+      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
+      described_class.commit
+    end
+
+    context "when use_valkyrie: true" do
+      let(:service) { described_class.new }
+
+      it "accepts and passes through use_valkyrie:true" do
+        expect(mock_conn).to receive(:commit)
+        allow(service).to receive(:valkyrie_index).and_return(double("valkyrie_index", connection: mock_conn))
+        service.commit use_valkyrie: true
+      end
+    end
+  end
+
+  describe ".delete_by_query" do
+    it "calls solr" do
+      expect(mock_conn).to receive(:delete_by_query).with("*:*", params: {})
+      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
+      described_class.delete_by_query("*:*")
+    end
+
+    context "when use_valkyrie: true" do
+      let(:service) { described_class.new }
+
+      it "accepts and passes through use_valkyrie:true" do
+        expect(mock_conn).to receive(:delete_by_query).with("*:*", params: {})
+        allow(service).to receive(:valkyrie_index).and_return(double("valkyrie_index", connection: mock_conn))
+        service.delete_by_query("*:*", use_valkyrie: true)
+      end
+    end
+  end
+
+  describe ".delete" do
+    before do
+      expect(mock_conn).to receive(:delete_by_id) do |_, opts|
+        expect(opts).to eq(params: { softCommit: true })
+      end
+    end
+
+    it "calls solr" do
+      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
+      described_class.delete("fade_solr_id#01")
+    end
+
+    context "when use_valkyrie: true" do
+      let(:service) { described_class.new }
+
+      it "accepts and passes through use_valkyrie:true" do
+        allow(service).to receive(:valkyrie_index).and_return(double("valkyrie_index", connection: mock_conn))
+        service.delete("fade_solr_id#01", use_valkyrie: true)
+      end
+    end
+  end
+
+  describe '.instance' do
+    let(:mock_instance) { double("instance", conn: mock_conn) }
+
+    it 'is deprecated' do
+      expect(mock_instance).to receive(:commit)
+      allow(Deprecation).to receive(:warn)
+      allow(described_class).to receive(:instance).and_return(mock_instance)
+      described_class.instance.commit
+    end
+  end
+
+  describe "#add" do
+    let(:mock_doc) { { "id" => "test_solr_doc#01" } }
+
+    before do
+      expect(mock_conn).to receive(:add) do |_, opts|
+        expect(opts).to eq(params: { softCommit: true })
+      end
+    end
+
+    it "calls solr" do
+      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
+      expect(described_class.add(mock_doc)).to eq true
+    end
+
+    it "uses the valkyrie solr core" do
+      service = described_class.new
+      allow(service).to receive(:valkyrie_index).and_return(double("valkyrie_index", connection: mock_conn))
+      expect(service.add(mock_doc, use_valkyrie: true)).to eq true
+    end
+  end
+
+  describe "#count" do
+    let(:stub_result) { { 'response' => { 'numFound' => '2' } } }
+
+    it "calls solr" do
+      expect(mock_conn).to receive(:get).with('select', params: { rows: 0, q: 'querytext', qt: 'standard' }).and_return(stub_result)
+      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
+      expect(described_class.count('querytext')).to eq 2
+    end
+
+    context "when use_valkyrie: true" do
+      it "uses the valkyrie solr core" do
+        service = described_class.new
+        expect(mock_conn).to receive(:get).with('select', params: { rows: 0, q: 'querytext' }).and_return(stub_result)
+        allow(service).to receive(:valkyrie_index).and_return(double("valkyrie_index", connection: mock_conn))
+        expect(service.count('querytext', use_valkyrie: true)).to eq 2
+      end
+    end
+  end
+end