hyrax 2.9.5 → 3.0.0.pre.beta1

data/spec/models/file_view_stat_spec.rb

@@ -0,0 +1,81 @@
+RSpec.describe FileViewStat, type: :model do
+  let(:file_id) { file.id }
+  let(:user_id) { 123 }
+  let(:date) { Time.current }
+  let(:file_stat) { described_class.create(views: "25", date: date, file_id: file_id, user_id: user_id) }
+  let(:file) { mock_model(FileSet, id: 99) }
+
+  it "has attributes" do
+    expect(file_stat).to respond_to(:views)
+    expect(file_stat).to respond_to(:date)
+    expect(file_stat).to respond_to(:file_id)
+    expect(file_stat.file_id).to eq("99")
+    expect(file_stat.date).to eq(date)
+    expect(file_stat.views).to eq(25)
+    expect(file_stat.user_id).to eq(user_id)
+  end
+
+  describe "#statistics" do
+    let(:dates) do
+      ldates = []
+      4.downto(0) { |idx| ldates << (Time.zone.today - idx.day) }
+      ldates
+    end
+    let(:date_strs) do
+      dates.map { |date| date.strftime("%Y%m%d") }
+    end
+
+    let(:view_output) do
+      [[statistic_date(dates[0]), 4], [statistic_date(dates[1]), 8], [statistic_date(dates[2]), 6], [statistic_date(dates[3]), 10]]
+    end
+
+    # This is what the data looks like that's returned from Google Analytics (GA) via the Legato gem
+    # Due to the nature of querying GA, testing this data in an automated fashion is problematc.
+    # Sample data structures were created by sending real events to GA from a test instance of
+    # Scholarsphere.  The data below are essentially a "cut and paste" from the output of query
+    # results from the Legato gem.
+    let(:sample_pageview_statistics) do
+      [
+        SpecStatistic.new(date: date_strs[0], pageviews: 4),
+        SpecStatistic.new(date: date_strs[1], pageviews: 8),
+        SpecStatistic.new(date: date_strs[2], pageviews: 6),
+        SpecStatistic.new(date: date_strs[3], pageviews: 10)
+      ]
+    end
+
+    describe "cache empty" do
+      let(:stats) do
+        expect(described_class).to receive(:ga_statistics).and_return(sample_pageview_statistics)
+        described_class.statistics(file, Time.zone.today - 4.days, user_id)
+      end
+
+      it "includes cached ga data" do
+        expect(stats.map(&:to_flot)).to include(*view_output)
+      end
+
+      it "caches data" do
+        expect(stats.map(&:to_flot)).to include(*view_output)
+        expect(stats.first.user_id).to eq user_id
+
+        # at this point all data should be cached
+        allow(described_class).to receive(:ga_statistics).with(Time.zone.today, file).and_raise("We should not call Google Analytics All data should be cached!")
+
+        stats2 = described_class.statistics(file, Time.zone.today - 5.days)
+        expect(stats2.map(&:to_flot)).to include(*view_output)
+      end
+    end
+
+    describe "cache loaded" do
+      let!(:file_view_stat) { described_class.create(date: (Time.zone.today - 5.days).to_datetime, file_id: file_id, views: "25") }
+
+      let(:stats) do
+        expect(described_class).to receive(:ga_statistics).and_return(sample_pageview_statistics)
+        described_class.statistics(file, Time.zone.today - 5.days)
+      end
+
+      it "includes cached data" do
+        expect(stats.map(&:to_flot)).to include([file_view_stat.date.to_i * 1000, file_view_stat.views], *view_output)
+      end
+    end
+  end
+end

data/spec/models/flipflop_spec.rb

@@ -0,0 +1,49 @@
+RSpec.describe Flipflop do
+  describe "assign_admin_set?" do
+    subject { described_class.assign_admin_set? }
+
+    it "defaults to true" do
+      is_expected.to be true
+    end
+  end
+
+  describe "proxy_deposit?" do
+    subject { described_class.proxy_deposit? }
+
+    it "defaults to true" do
+      is_expected.to be true
+    end
+  end
+
+  describe "transfer_works?" do
+    subject { described_class.transfer_works? }
+
+    it "defaults to true" do
+      is_expected.to be true
+    end
+  end
+
+  describe "batch_upload?" do
+    subject { described_class.batch_upload? }
+
+    it "defaults to true" do
+      is_expected.to be true
+    end
+  end
+
+  describe "hide_private_items?" do
+    subject { described_class.hide_private_items? }
+
+    it "defaults to false" do
+      is_expected.to be false
+    end
+  end
+
+  describe "hide_users_list?" do
+    subject { described_class.hide_users_list? }
+
+    it "defaults to true" do
+      is_expected.to be true
+    end
+  end
+end

data/spec/models/generic_work_spec.rb

@@ -0,0 +1,117 @@
+RSpec.describe GenericWork do
+  it 'has a title' do
+    subject.title = ['foo']
+    expect(subject.title).to eq ['foo']
+  end
+
+  describe '#active_workflow' do
+    it 'leverages "Sipity::Workflow.find_active_workflow_for"' do
+      expect(Sipity::Workflow).to receive(:find_active_workflow_for)
+      subject.active_workflow
+    end
+  end
+
+  describe '.model_name' do
+    subject { described_class.model_name.singular_route_key }
+
+    it { is_expected.to eq 'hyrax_generic_work' }
+  end
+
+  describe ".properties" do
+    subject { described_class.properties.keys }
+
+    it { is_expected.to include("has_model", "create_date", "modified_date") }
+  end
+
+  describe "to_sipity_entity" do
+    let(:state) { create(:workflow_state) }
+    let(:work) { create(:work) }
+
+    before do
+      Sipity::Entity.create!(proxy_for_global_id: work.to_global_id.to_s,
+                             workflow_state: state,
+                             workflow: state.workflow)
+    end
+    subject { work.to_sipity_entity }
+
+    it { is_expected.to be_kind_of Sipity::Entity }
+  end
+
+  describe '#state' do
+    let(:work) { described_class.new(state: inactive) }
+    let(:inactive) { ::RDF::URI('http://fedora.info/definitions/1/0/access/ObjState#inactive') }
+
+    it 'is inactive' do
+      expect(work.state.rdf_subject).to eq inactive
+    end
+
+    it 'allows state to be set to ActiveTriples::Resource' do
+      other_work = described_class.new(state: work.state)
+      expect(other_work.state.rdf_subject).to eq inactive
+    end
+  end
+
+  describe '#suppressed?' do
+    let(:work) { described_class.new(state: state) }
+
+    context "when state is inactive" do
+      let(:state) { ::RDF::URI('http://fedora.info/definitions/1/0/access/ObjState#inactive') }
+
+      it 'is suppressed' do
+        expect(work).to be_suppressed
+      end
+    end
+
+    context "when the state is active" do
+      let(:state) { ::RDF::URI('http://fedora.info/definitions/1/0/access/ObjState#active') }
+
+      it 'is not suppressed' do
+        expect(work).not_to be_suppressed
+      end
+    end
+
+    context "when the state is nil" do
+      let(:state) { nil }
+
+      it 'is not suppressed' do
+        expect(work).not_to be_suppressed
+      end
+    end
+  end
+
+  describe "delegations" do
+    let(:work) { described_class.new { |gw| gw.apply_depositor_metadata("user") } }
+    let(:proxy_depositor) { create(:user) }
+
+    before do
+      work.proxy_depositor = proxy_depositor.user_key
+    end
+    it "includes proxies" do
+      expect(work).to respond_to(:relative_path)
+      expect(work).to respond_to(:depositor)
+      expect(work.proxy_depositor).to eq proxy_depositor.user_key
+    end
+  end
+
+  describe "metadata" do
+    it "has descriptive metadata" do
+      expect(subject).to respond_to(:relative_path)
+      expect(subject).to respond_to(:depositor)
+      expect(subject).to respond_to(:related_url)
+      expect(subject).to respond_to(:based_near)
+      expect(subject).to respond_to(:contributor)
+      expect(subject).to respond_to(:creator)
+      expect(subject).to respond_to(:title)
+      expect(subject).to respond_to(:description)
+      expect(subject).to respond_to(:publisher)
+      expect(subject).to respond_to(:date_created)
+      expect(subject).to respond_to(:date_uploaded)
+      expect(subject).to respond_to(:date_modified)
+      expect(subject).to respond_to(:subject)
+      expect(subject).to respond_to(:language)
+      expect(subject).to respond_to(:license)
+      expect(subject).to respond_to(:resource_type)
+      expect(subject).to respond_to(:identifier)
+    end
+  end
+end

data/spec/models/hyrax/batch_create_operation_spec.rb

@@ -0,0 +1,59 @@
+RSpec.describe Hyrax::BatchCreateOperation do
+  subject { create(:batch_create_operation) }
+
+  describe 'callbacks' do
+    before do
+      allow(Hyrax.config.callback).to receive(:set?).with(callback).and_return(callback_set)
+    end
+
+    describe '#batch_success_message' do
+      let(:callback) { :after_batch_create_success }
+      let(:callback_set) { false }
+
+      it 'can be called' do
+        expect(subject).to respond_to(:batch_success_message)
+      end
+
+      context 'when callback not set' do
+        it 'returns nil' do
+          expect(Hyrax.config.callback).not_to receive(:run)
+          expect(subject.batch_success_message).to be_nil
+        end
+      end
+
+      context 'when callback is set' do
+        let(:callback_set) { true }
+
+        it 'runs the callback' do
+          expect(Hyrax.config.callback).to receive(:run).once
+          subject.batch_success_message
+        end
+      end
+    end
+
+    describe '#batch_failure_message' do
+      let(:callback) { :after_batch_create_failure }
+      let(:callback_set) { false }
+
+      it 'can be called' do
+        expect(subject).to respond_to(:batch_failure_message)
+      end
+
+      context 'when callback not set' do
+        it 'returns nil' do
+          expect(Hyrax.config.callback).not_to receive(:run)
+          expect(subject.batch_failure_message).to be_nil
+        end
+      end
+
+      context 'when callback is set' do
+        let(:callback_set) { true }
+
+        it 'runs the callback' do
+          expect(Hyrax.config.callback).to receive(:run).once
+          subject.batch_failure_message
+        end
+      end
+    end
+  end
+end

data/spec/models/hyrax/collection_type_participant_spec.rb

@@ -0,0 +1,43 @@
+RSpec.describe Hyrax::CollectionTypeParticipant, type: :model do
+  let(:collection_type_participant) { create(:collection_type_participant) }
+
+  it 'has basic metadata' do
+    expect(collection_type_participant).to respond_to(:agent_id)
+    expect(collection_type_participant.agent_id).not_to be_empty
+    expect(collection_type_participant).to respond_to(:agent_type)
+    expect(collection_type_participant.agent_type).not_to be_empty
+    expect(collection_type_participant).to respond_to(:access)
+    expect(collection_type_participant.access).not_to be_empty
+  end
+
+  describe "validations", :clean_repo do
+    describe '#agent_id' do
+      it { is_expected.to validate_presence_of(:agent_id) }
+    end
+    describe '#agent_type' do
+      it { is_expected.to validate_presence_of(:agent_type) }
+      it { is_expected.not_to allow_value('somethingelse').for(:agent_type) }
+      it { is_expected.to allow_value(Hyrax::CollectionTypeParticipant::USER_TYPE).for(:agent_type) }
+      it { is_expected.to allow_value(Hyrax::CollectionTypeParticipant::GROUP_TYPE).for(:agent_type) }
+      it "showd error message for wrong agent_type" do
+        collection_type_participant.agent_type = "BAD_TYPE"
+        collection_type_participant.valid?
+        expect(collection_type_participant.errors[:agent_type]).to include "BAD_TYPE is not a valid agent type.  Accepts: group, user"
+      end
+    end
+    describe '#access' do
+      it { is_expected.to validate_presence_of(:access) }
+      it { is_expected.not_to allow_value('somethingelse').for(:access) }
+      it { is_expected.to allow_value(Hyrax::CollectionTypeParticipant::MANAGE_ACCESS).for(:access) }
+      it { is_expected.to allow_value(Hyrax::CollectionTypeParticipant::CREATE_ACCESS).for(:access) }
+      it "showd error message for wrong access" do
+        collection_type_participant.access = "BAD_ACCESS"
+        collection_type_participant.valid?
+        expect(collection_type_participant.errors[:access]).to include "BAD_ACCESS is not a valid access.  Accepts: manage, create"
+      end
+    end
+    describe '#hyrax_collection_type_id' do
+      it { is_expected.to validate_presence_of(:hyrax_collection_type_id) }
+    end
+  end
+end

data/spec/models/hyrax/collection_type_spec.rb

@@ -0,0 +1,236 @@
+RSpec.describe Hyrax::CollectionType, type: :model do
+  let(:collection_type) { build(:collection_type) }
+
+  describe '.collection_type_settings_methods' do
+    subject { described_class.collection_type_settings_methods }
+
+    it { is_expected.to be_a(Array) }
+  end
+
+  describe '#collection_type_settings_methods' do
+    subject { described_class.new.collection_type_settings_methods }
+
+    it { is_expected.to be_a(Array) }
+  end
+
+  it "has basic metadata" do
+    expect(collection_type).to respond_to(:title)
+    expect(collection_type.title).not_to be_empty
+    expect(collection_type).to respond_to(:description)
+    expect(collection_type.description).not_to be_empty
+    expect(collection_type).to respond_to(:machine_id)
+  end
+
+  it "has configuration properties with defaults" do
+    expect(collection_type).to be_nestable
+    expect(collection_type).to be_brandable
+    expect(collection_type).to be_discoverable
+    expect(collection_type).to be_sharable
+    expect(collection_type).to be_share_applies_to_new_works
+    expect(collection_type).to allow_multiple_membership
+    expect(collection_type).not_to require_membership
+    expect(collection_type).not_to assign_workflow
+    expect(collection_type).not_to assign_visibility
+  end
+
+  describe '#gid' do
+    it 'returns the gid when id exists' do
+      collection_type.id = 5
+      expect(collection_type.gid.to_s).to eq 'gid://internal/hyrax-collectiontype/5'
+    end
+
+    it 'returns nil when id is nil' do
+      collection_type.id = nil
+      expect(collection_type.gid).to be_nil
+    end
+  end
+
+  describe ".any_nestable?" do
+    context "when there is a nestable collection type" do
+      let!(:collection_type) { create(:collection_type, nestable: true) }
+
+      it 'returns true' do
+        expect(described_class.any_nestable?).to be true
+      end
+    end
+
+    context "when there are no nestable collection types" do
+      let!(:collection_type) { create(:collection_type, nestable: false) }
+
+      it 'returns false' do
+        expect(described_class.any_nestable?).to be false
+      end
+    end
+  end
+
+  describe ".find_or_create_default_collection_type" do
+    subject { described_class.find_or_create_default_collection_type }
+
+    it 'creates a default collection type' do
+      expect(Hyrax::CollectionTypes::CreateService).to receive(:create_collection_type)
+      subject
+    end
+  end
+
+  describe ".find_or_create_admin_set_type" do
+    subject { described_class.find_or_create_admin_set_type }
+
+    it 'creates admin set collection type' do
+      machine_id = described_class::ADMIN_SET_MACHINE_ID
+      title = described_class::ADMIN_SET_DEFAULT_TITLE
+      expect(Hyrax::CollectionTypes::CreateService).to receive(:create_collection_type).with(machine_id: machine_id, title: title, options: anything)
+      subject
+    end
+  end
+
+  describe "validations", :clean_repo do
+    let(:collection_type) { create(:collection_type) }
+
+    it "ensures the required fields have values" do
+      collection_type.title = nil
+      collection_type.machine_id = nil
+      expect(collection_type).not_to be_valid
+      expect(collection_type.errors.messages[:title]).not_to be_empty
+      expect(collection_type.errors.messages[:machine_id]).not_to be_empty
+    end
+    it "ensures uniqueness" do
+      is_expected.to validate_uniqueness_of(:title)
+      is_expected.to validate_uniqueness_of(:machine_id)
+    end
+  end
+
+  describe '.find_by_gid' do
+    let(:collection_type) { create(:collection_type) }
+    let(:nonexistent_gid) { 'gid://internal/hyrax-collectiontype/NO_EXIST' }
+
+    it 'returns instance of collection type when one with the gid exists' do
+      expect(Hyrax::CollectionType.find_by_gid(collection_type.gid)).to eq collection_type
+    end
+
+    it 'returns false if collection type with gid does NOT exist' do
+      expect(Hyrax::CollectionType.find_by_gid(nonexistent_gid)).to eq false
+    end
+
+    it 'returns false if gid is nil' do
+      expect(Hyrax::CollectionType.find_by_gid(nil)).to eq false
+    end
+  end
+
+  describe '.find_by_gid!' do
+    let(:collection_type) { create(:collection_type) }
+    let(:nonexistent_gid) { 'gid://internal/hyrax-collectiontype/NO_EXIST' }
+
+    it 'returns instance of collection type when one with the gid exists' do
+      expect(Hyrax::CollectionType.find_by_gid(collection_type.gid)).to eq collection_type
+    end
+
+    it 'raises error if collection type with gid does NOT exist' do
+      expect { Hyrax::CollectionType.find_by_gid!(nonexistent_gid) }.to raise_error(ActiveRecord::RecordNotFound, "Couldn't find Hyrax::CollectionType matching GID '#{nonexistent_gid}'")
+    end
+
+    it 'raises error if passed nil' do
+      expect { Hyrax::CollectionType.find_by_gid!(nil) }.to raise_error(ActiveRecord::RecordNotFound, "Couldn't find Hyrax::CollectionType matching GID ''")
+    end
+  end
+
+  describe "collections" do
+    let!(:collection) { create(:collection, collection_type_gid: collection_type.gid.to_s) }
+    let(:collection_type) { create(:collection_type) }
+
+    it 'returns collections of this collection type' do
+      expect(collection_type.collections.to_a).to include collection
+    end
+
+    it 'returns empty array if gid is nil' do
+      expect(Collection.count).not_to be_zero
+      expect(build(:collection_type).collections).to eq []
+    end
+  end
+
+  describe "collections?", :clean_repo do
+    let(:collection_type) { create(:collection_type) }
+
+    it 'returns true if there are any collections of this collection type' do
+      create(:collection, collection_type_gid: collection_type.gid.to_s)
+      expect(collection_type).to have_collections
+    end
+    it 'returns false if there are not any collections of this collection type' do
+      expect(collection_type).not_to have_collections
+    end
+  end
+
+  describe "machine_id" do
+    let(:collection_type) { described_class.new }
+
+    it 'assigns machine_id on title=' do
+      expect(collection_type.machine_id).to be_blank
+      collection_type.title = "New Collection Type"
+      expect(collection_type.machine_id).not_to be_blank
+    end
+  end
+
+  describe "destroy" do
+    before do
+      allow(collection_type).to receive(:collections?).and_return(true)
+    end
+
+    it "fails if collections exist of this type" do
+      expect(collection_type.destroy).to eq false
+      expect(collection_type.errors).not_to be_empty
+    end
+  end
+
+  describe "save (no settings changes)" do
+    before do
+      allow(collection_type).to receive(:collections?).and_return(true)
+    end
+
+    it "succeeds no changes to settings are being made" do
+      expect(collection_type.save).to be true
+      expect(collection_type.errors).to be_empty
+    end
+  end
+
+  describe "save" do
+    before do
+      allow(collection_type).to receive(:changes).and_return('nestable' => false)
+    end
+
+    context 'for non-special collection type' do
+      before do
+        allow(collection_type).to receive(:collections?).and_return(true)
+      end
+
+      it "fails if collections exist of this type and settings are changed" do
+        expect(collection_type.save).to be false
+        expect(collection_type.errors.messages[:base].first).to eq "Collection type settings cannot be altered for a type that has collections"
+      end
+    end
+
+    context 'for admin set collection type' do
+      let(:collection_type) { create(:admin_set_collection_type) }
+
+      before do
+        allow(collection_type).to receive(:collections?).and_return(false)
+      end
+
+      it 'fails if settings are changed' do
+        expect(collection_type.save).to be false
+        expect(collection_type.errors.messages[:base].first).to eq "Collection type settings cannot be altered for the Administrative Set type"
+      end
+    end
+
+    context 'for user collection type' do
+      let(:collection_type) { create(:user_collection_type) }
+
+      before do
+        allow(collection_type).to receive(:collections?).and_return(false)
+      end
+
+      it 'fails if settings are changed' do
+        expect(collection_type.save).to be false
+        expect(collection_type.errors.messages[:base].first).to eq "Collection type settings cannot be altered for the User Collection type"
+      end
+    end
+  end
+end