hyrax 2.6.0 → 2.9.0

data/spec/lib/hyrax/resource_sync/resource_list_writer_spec.rb

@@ -1,25 +0,0 @@
-RSpec.describe Hyrax::ResourceSync::ResourceListWriter, :clean_repo do
-  let(:sitemap) { 'http://www.sitemaps.org/schemas/sitemap/0.9' }
-  let!(:private_collection) { build(:private_collection_lw) }
-  let!(:public_collection) { create(:public_collection) }
-  let!(:public_work) { create(:public_generic_work) }
-  let!(:private_work) { create(:work) }
-  let!(:file_set) { create(:file_set, :public) }
-  let(:capability_list) { 'http://example.com/capabilityList.xml' }
-  let(:xml) { Nokogiri::XML.parse(subject) }
-
-  subject { described_class.new(resource_host: 'example.com', capability_list_url: capability_list).write }
-
-  it "has a list of resources" do
-    capability = xml.xpath('//rs:ln/@href', 'rs' => "http://www.openarchives.org/rs/terms/").text
-    expect(capability).to eq capability_list
-    expect(query(1)).to eq "http://example.com/collections/#{public_collection.id}"
-    expect(query(2)).to eq "http://example.com/concern/generic_works/#{public_work.id}"
-    expect(query(3)).to eq "http://example.com/concern/file_sets/#{file_set.id}"
-    expect(xml.xpath('//x:url', 'x' => sitemap).count).to eq 3
-  end
-
-  def query(n)
-    xml.xpath("//x:url[#{n}]/x:loc", 'x' => sitemap).text
-  end
-end

data/spec/lib/hyrax/resource_sync/source_description_writer_spec.rb

@@ -1,18 +0,0 @@
-RSpec.describe Hyrax::ResourceSync::SourceDescriptionWriter do
-  let(:sitemap) { 'http://www.sitemaps.org/schemas/sitemap/0.9' }
-  let(:rs) { 'http://www.openarchives.org/rs/terms/' }
-  let(:capability_list) { 'http://example.com/capabilityList.xml' }
-  let(:xml) { Nokogiri::XML.parse(subject) }
-
-  subject { described_class.new(capability_list_url: capability_list).write }
-
-  it "has url to the capability list" do
-    capability = xml.xpath('/x:urlset/rs:md/@capability', 'x' => sitemap, 'rs' => rs).map(&:value)
-    expect(capability).to eq ["description"]
-
-    url = xml.xpath('//x:url[1]/x:loc', 'x' => sitemap).text
-    expect(url).to eq capability_list
-    capability = xml.xpath('//x:url[1]/rs:md/@capability', 'x' => sitemap, 'rs' => rs).map(&:value)
-    expect(capability).to eq ["capabilitylist"]
-  end
-end

data/spec/lib/hyrax/role_registry_spec.rb

@@ -1,43 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Hyrax::RoleRegistry do
-  let(:role_registry) { described_class.new }
-
-  describe '#role_names (without adding roles)' do
-    subject { role_registry.role_names }
-
-    it { is_expected.to eq(['approving', 'depositing', 'managing']) }
-  end
-
-  describe '#registered_role?' do
-    subject { role_registry.registered_role?(name: name) }
-
-    describe 'for already registered name' do
-      let(:name) { described_class::MANAGING }
-
-      it { is_expected.to be_truthy }
-    end
-    describe 'for non-registered name' do
-      let(:name) { 'gong_farming' }
-
-      it { is_expected.to be_falsey }
-    end
-  end
-
-  describe '#add' do
-    subject { role_registry.add(name: 'captaining', description: 'Grants captain duties') }
-
-    it 'includes those added via #add' do
-      expect { subject }.to change { role_registry.role_names }
-        .from(['approving', 'depositing', 'managing']).to(['approving', 'captaining', 'depositing', 'managing'])
-    end
-  end
-
-  describe '#persist_registered_roles!' do
-    subject { role_registry.persist_registered_roles! }
-
-    it 'creates Sipity::Role records for each role_name' do
-      expect { subject }.to change { Sipity::Role.count }.by(role_registry.role_names.count)
-    end
-  end
-end

data/spec/lib/hyrax/search_state_spec.rb

@@ -1,26 +0,0 @@
-RSpec.describe Hyrax::SearchState do
-  let(:controller) { CatalogController.new }
-  let(:config) { Blacklight::Configuration.new }
-  let(:state) { described_class.new({}, config, controller) }
-
-  describe "url_for_document" do
-    subject { state.url_for_document(document) }
-
-    context "with a collection" do
-      let(:document) { SolrDocument.new(id: '9999', has_model_ssim: ['Collection']) }
-
-      it "returns an array with the route set and doc" do
-        expect(subject.first).to be_kind_of ActionDispatch::Routing::RoutesProxy
-        expect(subject.last).to eq document
-      end
-    end
-    context "with a work" do
-      let(:document) { SolrDocument.new(id: '9999', has_model_ssim: ['GenericWork']) }
-
-      it "returns an array with the route set and doc" do
-        expect(subject.first).to be_kind_of ActionDispatch::Routing::RoutesProxy
-        expect(subject.last).to eq document
-      end
-    end
-  end
-end

data/spec/lib/hyrax/zotero/config_spec.rb

@@ -1,26 +0,0 @@
-RSpec.describe Hyrax::Zotero do
-  it { is_expected.to respond_to(:config) }
-
-  describe 'configuration' do
-    subject { described_class.reload_config! }
-
-    let(:client_key) { 'abc123' }
-    let(:client_secret) { '789xyz' }
-
-    before do
-      stub_const('ENV',           'ZOTERO_CLIENT_KEY' => client_key,
-                                  'ZOTERO_CLIENT_SECRET' => client_secret)
-    end
-
-    # Reload the config so other tests don't see the stub_const values
-    after { described_class.reload_config! }
-
-    it 'has a client key' do
-      expect(subject['client_key']).to eq(client_key)
-    end
-
-    it 'has a client secret' do
-      expect(subject['client_secret']).to eq(client_secret)
-    end
-  end
-end

data/spec/lib/hyrax/zotero_spec.rb

@@ -1,9 +0,0 @@
-RSpec.describe Hyrax::Zotero do
-  describe '.publications_url' do
-    let(:user_id) { 'foobar' }
-
-    it 'returns a string' do
-      expect(described_class.publications_url(user_id)).to eq "/users/#{user_id}/publications/items"
-    end
-  end
-end

data/spec/lib/hyrax_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Hyrax do
-  describe '.logger' do
-    it 'is a Logger' do
-      expect(described_class.logger).to respond_to :log
-    end
-  end
-end

data/spec/models/admin_set_spec.rb

@@ -1,229 +0,0 @@
-RSpec.describe AdminSet, type: :model do
-  let(:gf1) { create(:generic_work, user: user) }
-  let(:gf2) { create(:generic_work, user: user) }
-  let(:gf3) { create(:generic_work, user: user) }
-
-  let(:user) { create(:user) }
-
-  subject { described_class.new(title: ['Some title']) }
-
-  describe '#active_workflow' do
-    it 'leverages Sipity::Workflow.find_active_workflow_for' do
-      admin_set = build(:admin_set, id: 1234)
-      expect(Sipity::Workflow).to receive(:find_active_workflow_for).with(admin_set_id: admin_set.id).and_return(:workflow)
-      expect(admin_set.active_workflow).to eq(:workflow)
-    end
-  end
-
-  describe '#permission_template' do
-    it 'queries for a Hyrax::PermissionTemplate with a matching source_id' do
-      admin_set = build(:admin_set, id: '123')
-      permission_template = build(:permission_template)
-      expect(Hyrax::PermissionTemplate).to receive(:find_by!).with(source_id: '123').and_return(permission_template)
-      expect(admin_set.permission_template).to eq(permission_template)
-    end
-  end
-
-  describe 'factories' do
-    it 'will create a permission_template when one is requested' do
-      expect { create(:admin_set, with_permission_template: true) }.to change { Hyrax::PermissionTemplate.count }.by(1)
-    end
-
-    it 'will not create a permission_template by default' do
-      expect { create(:admin_set) }.not_to change { Hyrax::PermissionTemplate.count }
-    end
-
-    it 'will create a permission_template with attributes' do
-      permission_template = create(:admin_set,
-                                   with_permission_template: {
-                                     visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
-                                     release_date: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_FIXED,
-                                     release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_6_MONTHS
-                                   }).permission_template
-      expect(permission_template.visibility).to eq(Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
-      expect(permission_template.release_period).to eq(Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_6_MONTHS)
-      expect(permission_template.release_date).to eq(6.months.from_now.to_date)
-    end
-  end
-
-  describe '.after_destroy' do
-    let(:permission_template_access) { create(:permission_template_access) }
-
-    it 'will destroy the associated permission template and permission template access' do
-      admin_set = create(:admin_set, with_permission_template: true)
-      permission_template_access.permission_template_id = admin_set.permission_template.id
-      permission_template_access.save
-      expect { admin_set.destroy }.to change { Hyrax::PermissionTemplate.count }.by(-1).and change { Hyrax::PermissionTemplateAccess.count }.by(-1)
-    end
-  end
-
-  describe "#to_solr" do
-    let(:admin_set) do
-      build(:admin_set, title: ['A good title'],
-                        creator: ['jcoyne@justincoyne.com'])
-    end
-    let(:solr_document) { admin_set.to_solr }
-
-    it "has title and creator information" do
-      expect(solr_document).to include 'title_tesim' => ['A good title'],
-                                       'title_sim' => ['A good title'],
-                                       'creator_ssim' => ['jcoyne@justincoyne.com']
-    end
-  end
-
-  describe "#members" do
-    it "is empty by default" do
-      skip 'This test is plagued by this bug https://github.com/samvera/active_fedora/issues/1238'
-      expect(subject.members).to be_empty
-    end
-
-    context "adding members" do
-      context "using assignment" do
-        subject { described_class.create!(title: ['Some title'], members: [gf1, gf2]) }
-
-        it "has many files" do
-          expect(subject.reload.members).to match_array [gf1, gf2]
-        end
-      end
-
-      context "using append" do
-        before do
-          subject.members = [gf1]
-          subject.save
-        end
-        it "allows new files to be added" do
-          subject.reload
-          subject.members << gf2
-          subject.save
-          expect(subject.reload.members).to match_array [gf1, gf2]
-        end
-      end
-    end
-  end
-
-  describe ".default_set?" do
-    context "with default AdminSet ID" do
-      it "returns true" do
-        expect(AdminSet.default_set?(described_class::DEFAULT_ID)).to be true
-      end
-    end
-
-    context "with a non-default  ID" do
-      it "returns false" do
-        expect(AdminSet.default_set?('different-id')).to be false
-      end
-    end
-  end
-
-  describe "#default_set?", :clean_repo do
-    context "with default AdminSet ID" do
-      subject { described_class.new(id: described_class::DEFAULT_ID).default_set? }
-
-      it { is_expected.to be_truthy }
-    end
-
-    context "with a non-default  ID" do
-      subject { described_class.new(id: 'why-would-you-name-the-default-chupacabra?').default_set? }
-
-      it { is_expected.to be_falsey }
-    end
-  end
-
-  describe ".find_or_create_default_admin_set_id" do
-    subject { described_class.find_or_create_default_admin_set_id }
-
-    describe 'if it already exists' do
-      before { expect(described_class).to receive(:exists?).and_return(true) }
-      it 'returns the DEFAULT_ID without creating the admin set' do
-        expect(Hyrax::AdminSetCreateService).not_to receive(:create_default_admin_set)
-        expect(subject).to eq(described_class::DEFAULT_ID)
-      end
-    end
-    describe 'if it does not already exist' do
-      before { expect(described_class).to receive(:exists?).and_return(false) }
-      it 'returns the DEFAULT_ID and creates the admin set' do
-        expect(Hyrax::AdminSetCreateService).to receive(:create_default_admin_set).with(admin_set_id: described_class::DEFAULT_ID, title: described_class::DEFAULT_TITLE)
-        expect(subject).to eq(described_class::DEFAULT_ID)
-      end
-    end
-  end
-
-  describe "#destroy" do
-    context "with member works" do
-      before do
-        subject.members = [gf1, gf2]
-        subject.save!
-        subject.destroy
-      end
-
-      it "does not delete adminset or member works" do
-        expect(subject.errors.full_messages).to eq ["Administrative set cannot be deleted as it is not empty"]
-        expect(AdminSet.exists?(subject.id)).to be true
-        expect(GenericWork.exists?(gf1.id)).to be true
-        expect(GenericWork.exists?(gf2.id)).to be true
-      end
-    end
-
-    context "with no member works" do
-      before do
-        subject.members = []
-        subject.save!
-        subject.destroy
-      end
-
-      it "deletes the adminset" do
-        expect(AdminSet.exists?(subject.id)).to be false
-      end
-    end
-
-    context "is default adminset" do
-      before do
-        subject.members = []
-        subject.id = described_class::DEFAULT_ID
-        subject.save!
-        subject.destroy
-      end
-
-      it "does not delete the adminset" do
-        expect(subject.errors.full_messages).to eq ["Administrative set cannot be deleted as it is the default set"]
-        expect(AdminSet.exists?(described_class::DEFAULT_ID)).to be true
-      end
-    end
-  end
-
-  describe '#reset_access_controls!' do
-    let!(:user) { build(:user) }
-    let!(:admin_set) { create(:admin_set, creator: [user.user_key], edit_users: [user.user_key], edit_groups: [::Ability.admin_group_name], read_users: [], read_groups: ['public']) }
-    let!(:permission_template) { build(:permission_template) }
-
-    before do
-      allow(admin_set).to receive(:permission_template).and_return(permission_template)
-      allow(permission_template).to receive(:agent_ids_for).with(access: 'manage', agent_type: 'user').and_return(['mgr1@ex.com', 'mgr2@ex.com', user.user_key])
-      allow(permission_template).to receive(:agent_ids_for).with(access: 'manage', agent_type: 'group').and_return(['managers', ::Ability.admin_group_name])
-      allow(permission_template).to receive(:agent_ids_for).with(access: 'deposit', agent_type: 'user').and_return(['dep1@ex.com', 'dep2@ex.com'])
-      allow(permission_template).to receive(:agent_ids_for).with(access: 'deposit', agent_type: 'group').and_return(['depositors', 'registered'])
-      allow(permission_template).to receive(:agent_ids_for).with(access: 'view', agent_type: 'user').and_return(['vw1@ex.com', 'vw2@ex.com'])
-      allow(permission_template).to receive(:agent_ids_for).with(access: 'view', agent_type: 'group').and_return(['viewers', 'public'])
-    end
-
-    it 'resets user edit access' do
-      admin_set.reset_access_controls!
-      expect(admin_set.edit_users).to match_array([user.user_key, 'mgr1@ex.com', 'mgr2@ex.com'])
-    end
-
-    it 'resets group edit access' do
-      admin_set.reset_access_controls!
-      expect(admin_set.edit_groups).to match_array(['managers', ::Ability.admin_group_name])
-    end
-
-    it 'resets user read access' do
-      admin_set.reset_access_controls!
-      expect(admin_set.read_users).to match_array(['dep1@ex.com', 'dep2@ex.com', 'vw1@ex.com', 'vw2@ex.com'])
-    end
-
-    it 'resets group read access' do
-      admin_set.reset_access_controls!
-      expect(admin_set.read_groups).to match_array(['depositors', 'viewers'])
-    end
-  end
-end

data/spec/models/batch_upload_item_spec.rb

@@ -1,7 +0,0 @@
-RSpec.describe BatchUploadItem do
-  describe ".human_readable_type" do
-    subject { described_class.human_readable_type }
-
-    it { is_expected.to eq 'Works by Batch' }
-  end
-end

data/spec/models/checksum_audit_log_spec.rb

@@ -1,162 +0,0 @@
-RSpec.describe ChecksumAuditLog do
-  let(:f) do
-    file = FileSet.create do |gf|
-      gf.apply_depositor_metadata('mjg36')
-    end
-    # TODO: Mock addition of file to fileset to avoid calls to .save.
-    # This will speed up tests and avoid uneccesary integration testing for fedora funcationality.
-    Hydra::Works::AddFileToFileSet.call(file, File.open(fixture_path + '/world.png'), :original_file)
-    file
-  end
-
-  let(:version_uri) do
-    Hyrax::VersioningService.create(f.original_file)
-    f.original_file.versions.first.uri
-  end
-  let(:content_id) { f.original_file.id }
-  let(:old) { described_class.create(file_set_id: f.id, file_id: content_id, checked_uri: version_uri, passed: true, created_at: 2.minutes.ago) }
-  let(:new) { described_class.create(file_set_id: f.id, file_id: content_id, checked_uri: version_uri, passed: false, created_at: 1.minute.ago) }
-
-  context 'a file with multiple checksums' do
-    it 'returns a list of logs for this FileSet sorted by date descending' do
-      logs = described_class.logs_for(f.id, checked_uri: version_uri)
-      expect(logs).to eq([new, old])
-    end
-  end
-
-  describe ".create_and_prune!" do
-    let(:file_set_id) { 'file_set_id' }
-    let(:checked_uri) { "file_id/fcr:versions/version1" }
-
-    subject { described_class.create_and_prune!(passed: passed, file_set_id: 'file_set_id', file_id: 'file_id', checked_uri: checked_uri, expected_result: '1234') }
-
-    describe 'when check passed' do
-      let(:passed) { true }
-
-      it { is_expected.to be_a(described_class) }
-      it 'will prune history' do
-        expect(described_class).to receive(:prune_history).with(file_set_id, checked_uri: checked_uri)
-        subject
-      end
-    end
-    describe 'when check failed' do
-      let(:passed) { false }
-
-      it { is_expected.to be_a(described_class) }
-      it 'will not prune history' do
-        expect(described_class).not_to receive(:prune_history).with(file_set_id, checked_uri: checked_uri)
-        subject
-      end
-    end
-  end
-
-  describe ".prune_history" do
-    let(:file_set_id) { "file_set_id" }
-    let(:file_id) { "file_id" }
-    let(:version_uri) { "#{file_id}/fcr:versions/version1" }
-
-    context "one passing record" do
-      let!(:record) { described_class.create(created_at: 1.day.ago, file_set_id: file_set_id, file_id: file_id, checked_uri: version_uri, passed: true) }
-
-      before do
-        described_class.prune_history(file_set_id, checked_uri: version_uri)
-      end
-
-      it "keeps record" do
-        expect(described_class.logs_for(file_set_id, checked_uri: version_uri).count).to eq(1)
-      end
-    end
-
-    context "two passing records" do
-      let!(:older) { described_class.create(created_at: 1.day.ago, file_set_id: file_set_id, file_id: file_id, checked_uri: version_uri, passed: true) }
-      let!(:newer) { described_class.create(created_at: 0.days.ago, file_set_id: file_set_id, file_id: file_id, checked_uri: version_uri, passed: true) }
-
-      before do
-        described_class.prune_history(file_set_id, checked_uri: version_uri)
-      end
-
-      it "keeps latest, gets rid of previous" do
-        logs = described_class.logs_for(file_set_id, checked_uri: version_uri).to_a
-        expect(logs.length).to eq 1
-        expect(logs.first.id).to eq newer.id
-      end
-    end
-
-    context "complex history" do
-      let!(:first)  { described_class.create(file_set_id: file_set_id, file_id: file_id, checked_uri: version_uri, passed: true) }
-      let!(:second) { described_class.create(file_set_id: file_set_id, file_id: file_id, checked_uri: version_uri, passed: true) }
-      let!(:third)  { described_class.create(file_set_id: file_set_id, file_id: file_id, checked_uri: version_uri, passed: false) }
-      let!(:fourth) { described_class.create(file_set_id: file_set_id, file_id: file_id, checked_uri: version_uri, passed: true) }
-      let!(:fifth)  { described_class.create(file_set_id: file_set_id, file_id: file_id, checked_uri: version_uri, passed: true) }
-      let!(:sixth)  { described_class.create(file_set_id: file_set_id, file_id: file_id, checked_uri: version_uri, passed: true) }
-
-      before do
-        described_class.prune_history(file_set_id, checked_uri: version_uri)
-      end
-      it "keeps latest, failing, and previous/next of failing" do
-        logs = described_class.logs_for(file_set_id, checked_uri: version_uri).reorder("created_at asc")
-        expect(logs.collect(&:id)).to eq([second.id, third.id, fourth.id, sixth.id])
-        expect(logs.collect(&:passed)).to eq([true, false, true, true])
-      end
-    end
-
-    context 'after multiple checksum events where the checksum does not change' do
-      specify 'only one of them should be kept' do
-        success1 = described_class.create(file_set_id: f.id, file_id: content_id, checked_uri: version_uri, passed: true)
-        described_class.prune_history(f.id, checked_uri: version_uri)
-        success2 = described_class.create(file_set_id: f.id, file_id: content_id, checked_uri: version_uri, passed: true)
-        described_class.prune_history(f.id, checked_uri: version_uri)
-        success3 = described_class.create(file_set_id: f.id, file_id: content_id, checked_uri: version_uri, passed: true)
-
-        described_class.prune_history(f.id, checked_uri: version_uri)
-
-        expect { described_class.find(success1.id) }.to raise_exception ActiveRecord::RecordNotFound
-        expect { described_class.find(success2.id) }.to raise_exception ActiveRecord::RecordNotFound
-        expect(described_class.find(success3.id)).not_to be_nil
-        logs = described_class.logs_for(f.id, checked_uri: version_uri)
-        expect(logs.collect(&:id)).to eq([success3.id])
-      end
-    end
-  end
-
-  context "multiple versions with multiple checks" do
-    # I don't quite understand how our FileSet already has multiple
-    # versions, but that's great since I couldn't figure out a reasonable
-    # way to create them. Note you need to #all here, or you get
-    # really confusing stuff.
-    let(:verisons_uri) { f.original_file.versions.all.first.uri }
-    let(:version_uri2) { f.original_file.versions.all.second.uri }
-
-    before do
-      described_class.create(file_set_id: f.id, file_id: content_id, checked_uri: version_uri, passed: true, created_at: 2.days.ago)
-      described_class.create(file_set_id: f.id, file_id: content_id, checked_uri: version_uri, passed: true, created_at: 1.day.ago)
-      described_class.create(file_set_id: f.id, file_id: content_id, checked_uri: version_uri, passed: true)
-
-      described_class.create(file_set_id: f.id, file_id: content_id, checked_uri: version_uri2, passed: true, created_at: 2.days.ago)
-      described_class.create(file_set_id: f.id, file_id: content_id, checked_uri: version_uri2, passed: false, created_at: 1.day.ago)
-      described_class.create(file_set_id: f.id, file_id: content_id, checked_uri: version_uri2, passed: true)
-    end
-    describe ".latest_checks" do
-      it "returns only latest for each checked_uri" do
-        expected = [
-          described_class.where(checked_uri: version_uri).order("created_at desc").first,
-          described_class.where(checked_uri: version_uri2).order("created_at desc").first
-        ]
-        expect(described_class.latest_checks).to match_array(expected)
-      end
-    end
-    describe ".latest_for_file_set_id" do
-      before do
-        # add some for another file set, doens't matter it doesn't exist
-        described_class.create(file_set_id: "somethingelse", file_id: "whatever", checked_uri: "http://example.org/w")
-      end
-      it "returns only the lastest check for FileSet specified" do
-        expected = [
-          described_class.where(checked_uri: version_uri).order("created_at desc").first,
-          described_class.where(checked_uri: version_uri2).order("created_at desc").first
-        ]
-        expect(described_class.latest_for_file_set_id(f.id)).to match_array(expected)
-      end
-    end
-  end
-end