hyrax 2.6.0 → 2.7.0

data/spec/models/trophy_spec.rb

@@ -1,19 +0,0 @@
-RSpec.describe Trophy, type: :model do
-  let(:trophy) { described_class.create(user_id: 99, work_id: "99") }
-
-  it "has a user" do
-    expect(trophy).to respond_to(:user_id)
-    expect(trophy.user_id).to eq(99)
-  end
-
-  it "has a work" do
-    expect(trophy).to respond_to(:work_id)
-    expect(trophy.work_id).to eq("99")
-  end
-
-  it "does not allow six trophies" do
-    (1..6).each { |n| described_class.create(user_id: 120, work_id: n.to_s) }
-    expect(described_class.where(user_id: 120).count).to eq(5)
-    described_class.where(user_id: 120).map(&:delete)
-  end
-end

data/spec/models/user_mailbox_spec.rb

@@ -1,134 +0,0 @@
-RSpec.describe UserMailbox do
-  let(:user)         { create(:user) }
-  let(:another_user) { create(:user) }
-
-  before do
-    another_user.send_message(user, "Test Message", "Test Subject")
-    user.send_message(another_user, "Test Message", "Test Subject")
-  end
-
-  subject { described_class.new(user) }
-
-  describe "#inbox" do
-    subject { described_class.new(user).inbox.first.last_message }
-
-    it "has mail" do
-      expect(subject.body).to eq('Test Message')
-      expect(subject.subject).to eq('Test Subject')
-      expect(user.mailbox.inbox(unread: true).count).to eq(0)
-    end
-  end
-
-  describe '#unread_count' do
-    it 'returns the number of unread messages for a user' do
-      expect { another_user.send_message(user, 'Another Test', '[subj]') }
-        .to change { subject.unread_count }.from(1).to(2)
-    end
-  end
-
-  describe '#label' do
-    # rubocop:disable RSpec/SubjectStub
-    before do
-      allow(subject).to receive(:unread_count).and_return(count)
-    end
-    # rubocop:enable RSpec/SubjectStub
-
-    context 'with zero unread messages' do
-      let(:count) { 0 }
-
-      it 'returns the appropriate label' do
-        expect(subject.label).to eq 'You have no unread notifications'
-      end
-    end
-
-    context 'with one unread message' do
-      let(:count) { 1 }
-
-      it 'returns the appropriate label' do
-        expect(subject.label).to eq 'You have one unread notification'
-      end
-    end
-
-    context 'with multiple unread messages' do
-      let(:count) { 5 }
-
-      it 'returns the appropriate label' do
-        expect(subject.label).to eq 'You have 5 unread notifications'
-      end
-    end
-
-    describe 'locales' do
-      let(:count) { 3 }
-
-      context 'when param is passed' do
-        it 'returns the label in the specified locale' do
-          expect(subject.label('es')).to eq 'Tienes notificaciones no leídas de 3'
-        end
-      end
-
-      context 'when param is not passed' do
-        before { allow(user).to receive(:preferred_locale).and_return(preferred_locale) }
-
-        context 'when user has a preferred locale' do
-          let(:preferred_locale) { 'it' }
-
-          it 'returns the label in the user-preferred locale' do
-            expect(I18n).not_to receive(:default_locale)
-            expect(subject.label).to eq 'Hai notifiche non letti 3'
-          end
-        end
-
-        context 'when user lacks a preferred locale' do
-          let(:preferred_locale) { nil }
-
-          it 'returns the system default locale' do
-            expect(I18n).to receive(:default_locale).once.and_return('de')
-            expect(subject.label).to eq 'Sie haben 3 ungelesene Benachrichtigungen'
-          end
-        end
-      end
-    end
-  end
-
-  describe "#delete_all" do
-    before do
-      another_user.send_message(user, 'message 2', 'subject 2')
-      another_user.send_message(user, 'message 3', 'subject 3')
-    end
-    it "deletes all messages" do
-      expect(user.mailbox.inbox.count).to eq(3)
-      subject.delete_all
-      expect(user.mailbox.inbox.count).to eq(0)
-    end
-  end
-
-  describe "#delete" do
-    let(:rec)         { another_user.send_message(user, 'message 2', 'subject 2') }
-    let!(:message_id) { rec.conversation.id }
-
-    it "deletes a message" do
-      subject.destroy message_id
-      expect { Mailboxer::Conversation.find(message_id) }.to raise_error(ActiveRecord::RecordNotFound)
-    end
-
-    context "non-existing conversation" do
-      let!(:message_id) { -99 }
-
-      it "raises an error" do
-        expect { subject.destroy message_id }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-
-    context "deleting a message from a third party" do
-      let(:curator)     { create(:user) }
-      let(:message)     { another_user.send_message(curator, 'message 3', 'subject 3') }
-      let!(:message_id) { message.conversation.id }
-
-      it "does not delete the message" do
-        subject.destroy message_id
-        expect(subject.destroy(message_id)).to eq "You do not have privileges to delete the notification..."
-        expect(Mailboxer::Conversation.find(message_id).id).to eq message_id
-      end
-    end
-  end
-end

data/spec/models/user_spec.rb

@@ -1,269 +0,0 @@
-RSpec.describe User, type: :model do
-  let(:user) { build(:user) }
-  let(:another_user) { build(:user) }
-
-  describe 'verifying factories' do
-    describe ':user' do
-      let(:user) { build(:user) }
-
-      it 'will, by default, have no groups' do
-        expect(user.groups).to eq([])
-        user.save!
-        # Ensuring that we can refind it and have the correct groups
-        expect(user.class.find(user.id).groups).to eq([])
-      end
-      it 'will allow for override of groups' do
-        user = build(:user, groups: 'chicken')
-        expect(user.groups).to eq(['chicken'])
-        user.save!
-        # Ensuring that we can refind it and have the correct groups
-        expect(user.class.find(user.id).groups).to eq(['chicken'])
-      end
-    end
-    describe ':admin' do
-      let(:admin_user) { create(:admin) }
-
-      it 'will have an "admin" group' do
-        expect(admin_user.groups).to eq(['admin'])
-      end
-      context 'when found from the database' do
-        it 'will have the expected "admin" group' do
-          refound_admin_user = described_class.find(admin_user.id)
-          expect(refound_admin_user.groups).to eq(['admin'])
-        end
-      end
-    end
-  end
-
-  it "has an email" do
-    expect(user.user_key).to be_kind_of String
-  end
-  it "has activity stream-related methods defined" do
-    expect(user).to respond_to(:stream)
-    expect(user).to respond_to(:events)
-    expect(user).to respond_to(:profile_events)
-    expect(user).to respond_to(:log_event)
-    expect(user).to respond_to(:log_profile_event)
-  end
-  it "has social attributes" do
-    expect(user).to respond_to(:twitter_handle)
-    expect(user).to respond_to(:facebook_handle)
-    expect(user).to respond_to(:googleplus_handle)
-    expect(user).to respond_to(:linkedin_handle)
-    expect(user).to respond_to(:orcid)
-  end
-
-  describe 'Arkivo and Zotero integration' do
-    it 'sets an Arkivo token after_initialize if API is enabled' do
-      expect(described_class.new).to respond_to(:arkivo_token)
-    end
-
-    describe 'Arkivo token generation' do
-      before do
-        allow(SecureRandom).to receive(:base64).with(24).and_return(token1, token1, token2)
-      end
-
-      let(:token1) { 'token1' }
-      let(:token2) { 'token2' }
-
-      it 'generates a new token if a user is found with the existing token' do
-        user1 = described_class.create(email: 'foo@example.org', password: 'foobarbaz')
-        expect(user1.arkivo_token).to eq token1
-        user2 = described_class.create(email: 'bar@example.org', password: 'bazquuxquuux')
-        expect(user2.arkivo_token).to eq token2
-      end
-    end
-
-    describe 'Zotero tokens' do
-      let(:token) { 'something' }
-
-      it 'has a custom getter/setter for Zotero request tokens' do
-        user.zotero_token = token
-        expect(user.read_attribute(:zotero_token)).to eq Marshal.dump(token)
-        expect(user.zotero_token).to eq token
-      end
-    end
-  end
-
-  describe 'ORCID validation and normalization' do
-    it 'saves when a valid bare ORCID is supplied' do
-      user.orcid = '0000-0000-1111-2222'
-      expect(user).to be_valid
-      expect(user.save).to be true
-    end
-    it 'saves when an ORCID with a non-numeric check digit is provided' do
-      user.orcid = 'http://orcid.org/0000-0000-1111-222X'
-      expect(user).to be_valid
-      expect(user.save).to be true
-    end
-    it 'saves when a valid ORCID HTTP URI w/ trailing slash is supplied' do
-      user.orcid = 'http://orcid.org/0000-0000-1111-2222/'
-      expect(user).to be_valid
-      expect(user.save).to be true
-    end
-    it 'saves when a valid ORCID HTTPS URI is supplied' do
-      user.orcid = 'https://orcid.org/0000-0000-1111-2222'
-      expect(user).to be_valid
-      expect(user.save).to be true
-    end
-    it 'normalizes bare ORCIDs to HTTPS URIs' do
-      user.orcid = '0000-0000-1111-2222'
-      user.save
-      expect(user.orcid).to eq 'https://orcid.org/0000-0000-1111-2222'
-    end
-    it 'normalizes HTTP ORCIDs to HTTPS URIs' do
-      user.orcid = 'http://orcid.org/0000-0000-1111-2222'
-      user.save
-      expect(user.orcid).to eq 'https://orcid.org/0000-0000-1111-2222'
-    end
-    it 'marks short ORCIDs as invalid' do
-      user.orcid = '000-000-111-222'
-      expect(user).not_to be_valid
-      expect(user.save).to be false
-    end
-    it 'marks long ORCIDs as invalid' do
-      user.orcid = '0000-0000-1111-222222'
-      expect(user).not_to be_valid
-      expect(user.save).to be false
-    end
-  end
-
-  describe "#to_param" do
-    let(:user) { described_class.new(email: 'jilluser@example.com') }
-
-    it "overrides to_param to make keys more recognizable in redis (and useable within Rails URLs)" do
-      expect(user.to_param).to eq("jilluser@example-dot-com")
-    end
-  end
-
-  subject { user }
-
-  it { is_expected.to delegate_method(:can?).to(:ability) }
-  it { is_expected.to delegate_method(:cannot?).to(:ability) }
-
-  describe '#to_sipity_agent' do
-    subject { user.to_sipity_agent }
-
-    it 'will find or create a Sipity::Agent' do
-      user.save!
-      expect { subject }.to change { Sipity::Agent.count }.by(1)
-    end
-
-    it 'will fail if the User is not persisted' do
-      expect { subject }.to raise_error(ActiveRecord::StatementInvalid)
-    end
-
-    context "when another process makes the agent" do
-      let(:user) { create(:user) }
-
-      before do
-        user.sipity_agent # load up and cache the association
-        User.find(user.id).create_sipity_agent!
-      end
-      it "returns the existing agent" do
-        expect { subject }.not_to change { Sipity::Agent.count }
-      end
-    end
-  end
-
-  describe "activity streams" do
-    let(:now) { Time.zone.now.to_i }
-    let(:activities) do
-      [{ action: 'so and so edited their profile', timestamp: now },
-       { action: 'so and so uploaded a file', timestamp: (now - 360) }]
-    end
-    let(:file_activities) do
-      [{ action: 'uploaded a file', timestamp: now + 1 }]
-    end
-
-    before do
-      allow(user).to receive(:events).and_return(activities)
-      allow(user).to receive(:profile_events).and_return(file_activities)
-    end
-
-    it "gathers the user's recent activity within the default amount of time" do
-      expect(user.all_user_activity).to eq(file_activities.concat(activities))
-    end
-
-    it "gathers the user's recent activity within a given timestamp" do
-      expect(user.all_user_activity(now - 60)).to eq(file_activities.concat([activities.first]))
-    end
-  end
-  describe "proxy_deposit_rights" do
-    subject { create :user }
-
-    before do
-      subject.can_receive_deposits_from << user
-      subject.can_make_deposits_for << another_user
-      subject.save!
-    end
-    it "can_receive_deposits_from" do
-      expect(subject.can_receive_deposits_from.to_a).to eq [user]
-      expect(user.can_make_deposits_for.to_a).to eq [subject]
-    end
-    it "can_make_deposits_for" do
-      expect(subject.can_make_deposits_for.to_a).to eq [another_user]
-      expect(another_user.can_receive_deposits_from.to_a).to eq [subject]
-    end
-  end
-  describe "class methods" do
-    describe "recent_users" do
-      let(:new_users) { described_class.all.order(created_at: :desc) }
-
-      before do
-        (1..3).each { |i| described_class.create(email: "abc#{i}@blah.frg", password: "blarg1234", created_at: Time.zone.now - i.days) }
-      end
-
-      context "when has a start date" do
-        subject { described_class.recent_users(Time.zone.today - 2.days) }
-
-        it "returns valid data" do
-          expect(subject.count).to eq 2
-          is_expected.to include(new_users[0], new_users[1])
-          is_expected.not_to include(new_users[2])
-        end
-      end
-
-      context "when has start and end date" do
-        subject { described_class.recent_users(Time.zone.today - 2.days, Time.zone.today - 1.day) }
-
-        it "returns valid data" do
-          expect(subject.count).to eq 1
-          is_expected.to include(new_users[1])
-          is_expected.not_to include(new_users[2], new_users[0])
-        end
-      end
-    end
-  end
-  describe "scope Users" do
-    let!(:basic_user) { create(:user) }
-    let!(:guest_user) { create(:user, :guest) }
-    let!(:audit_user) { User.audit_user }
-    let!(:batch_user) { User.batch_user }
-
-    context "without_system_accounts" do
-      subject { described_class.without_system_accounts }
-
-      it "omits audit_user and batch_user" do
-        is_expected.to include(basic_user, guest_user)
-        is_expected.not_to include(audit_user, batch_user)
-      end
-    end
-    context "registered" do
-      subject { described_class.registered }
-
-      it "omits guest_user" do
-        is_expected.to include(basic_user, audit_user, batch_user)
-        is_expected.not_to include(guest_user)
-      end
-    end
-    context "guests" do
-      subject { described_class.guests }
-
-      it "includes only guest_user" do
-        is_expected.not_to include(basic_user, audit_user, batch_user)
-        is_expected.to include(guest_user)
-      end
-    end
-  end
-end

data/spec/models/work_view_stat_spec.rb

@@ -1,107 +0,0 @@
-RSpec.describe WorkViewStat, type: :model do
-  let(:work_id) { work.id }
-  let(:user_id) { 123 }
-  let(:date) { DateTime.new.in_time_zone }
-  let(:work_stat) { described_class.create(work_views: "25", date: date, work_id: work_id, user_id: user_id) }
-  let(:work) { mock_model(GenericWork, id: 199) }
-
-  it "has attributes" do
-    expect(work_stat).to respond_to(:work_views)
-    expect(work_stat).to respond_to(:date)
-    expect(work_stat).to respond_to(:work_id)
-    expect(work_stat.work_id).to eq("199")
-    expect(work_stat.date).to eq(date)
-    expect(work_stat.work_views).to eq(25)
-    expect(work_stat.user_id).to eq(user_id)
-  end
-
-  describe ".ga_statistic" do
-    let(:start_date) { 2.days.ago }
-    let(:expected_path) { Rails.application.routes.url_helpers.hyrax_generic_work_path(work) }
-
-    before do
-      allow(Hyrax::Analytics).to receive(:profile).and_return(profile)
-    end
-    context "when a profile is available" do
-      let(:views) { double }
-      let(:profile) { double(hyrax__pageview: views) }
-
-      it "calls the Legato method with the correct path" do
-        expect(views).to receive(:for_path).with(expected_path)
-        described_class.ga_statistics(start_date, work)
-      end
-    end
-
-    context "when a profile not available" do
-      let(:profile) { nil }
-
-      it "calls the Legato method with the correct path" do
-        expect(described_class.ga_statistics(start_date, work)).to be_empty
-      end
-    end
-  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_work_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_work_pageview_statistics)
-        described_class.statistics(work, 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, work).and_raise("We should not call Google Analytics All data should be cached!")
-
-        stats2 = described_class.statistics(work, Time.zone.today - 5.days)
-        expect(stats2.map(&:to_flot)).to include(*view_output)
-      end
-    end
-
-    describe "cache loaded" do
-      let!(:work_view_stat) { described_class.create(date: (Time.zone.today - 5.days).to_datetime, work_id: work_id, work_views: "25") }
-
-      let(:stats) do
-        expect(described_class).to receive(:ga_statistics).and_return(sample_work_pageview_statistics)
-        described_class.statistics(work, Time.zone.today - 5.days)
-      end
-
-      it "includes cached data" do
-        expect(stats.map(&:to_flot)).to include([work_view_stat.date.to_i * 1000, work_view_stat.work_views], *view_output)
-      end
-    end
-  end
-end