test_hyrax 0.0.1.alpha

data/spec/models/sipity/role_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module Sipity
+  RSpec.describe Role, type: :model, no_clean: true do
+    context 'class methods' do
+      subject { described_class }
+      its(:column_names) { is_expected.to include('name') }
+      its(:column_names) { is_expected.to include('description') }
+      context '.[]' do
+        let(:valid_name) { 'reviewing' }
+
+        it 'will find the named role' do
+          expected_object = described_class.create!(name: valid_name)
+          expect(described_class[valid_name]).to eq(expected_object)
+        end
+
+        it 'will created the named role' do
+          expect { described_class[valid_name].name }.to change { described_class.count }.by(1)
+        end
+      end
+    end
+
+    subject { described_class.new }
+
+    it 'will have a #to_s that is a name' do
+      subject.name = 'advising'
+      expect(subject.to_s).to eq(subject.name)
+    end
+  end
+end

data/spec/models/sipity/workflow_action_spec.rb

@@ -0,0 +1,10 @@
+module Sipity
+  RSpec.describe WorkflowAction, type: :model, no_clean: true do
+    context 'database configuration' do
+      subject { described_class }
+      its(:column_names) { is_expected.to include('workflow_id') }
+      its(:column_names) { is_expected.to include('resulting_workflow_state_id') }
+      its(:column_names) { is_expected.to include('name') }
+    end
+  end
+end

data/spec/models/sipity/workflow_responsibility_spec.rb

@@ -0,0 +1,7 @@
+module Sipity
+  RSpec.describe WorkflowResponsibility, type: :model, no_clean: true do
+    subject { described_class }
+    its(:column_names) { is_expected.to include('agent_id') }
+    its(:column_names) { is_expected.to include('workflow_role_id') }
+  end
+end

data/spec/models/sipity/workflow_role_spec.rb

@@ -0,0 +1,7 @@
+module Sipity
+  RSpec.describe WorkflowRole, type: :model, no_clean: true do
+    subject { described_class }
+    its(:column_names) { is_expected.to include('workflow_id') }
+    its(:column_names) { is_expected.to include('role_id') }
+  end
+end

data/spec/models/sipity/workflow_spec.rb

@@ -0,0 +1,15 @@
+module Sipity
+  RSpec.describe Workflow, type: :model, no_clean: true do
+    subject { described_class }
+    its(:column_names) { is_expected.to include('name') }
+
+    context '#initial_workflow_state' do
+      subject { described_class.new(name: 'ETD Workflow') }
+      it 'will create a state if one does not exist' do
+        subject.save!
+        expect { subject.initial_workflow_state }
+          .to change { subject.workflow_states.count }.by(1)
+      end
+    end
+  end
+end

data/spec/models/sipity/workflow_state_action_permission_spec.rb

@@ -0,0 +1,7 @@
+module Sipity
+  RSpec.describe WorkflowStateActionPermission, type: :model, no_clean: true do
+    subject { described_class }
+    its(:column_names) { is_expected.to include("workflow_role_id") }
+    its(:column_names) { is_expected.to include("workflow_state_action_id") }
+  end
+end

data/spec/models/sipity/workflow_state_action_spec.rb

@@ -0,0 +1,7 @@
+module Sipity
+  RSpec.describe WorkflowStateAction, type: :model, no_clean: true do
+    subject { described_class }
+    its(:column_names) { is_expected.to include("originating_workflow_state_id") }
+    its(:column_names) { is_expected.to include("workflow_action_id") }
+  end
+end

data/spec/models/sipity/workflow_state_spec.rb

@@ -0,0 +1,15 @@
+module Sipity
+  RSpec.describe WorkflowState, type: :model, no_clean: true do
+    subject { described_class }
+    its(:column_names) { is_expected.to include("workflow_id") }
+    its(:column_names) { is_expected.to include("name") }
+
+    describe "#entities" do
+      let(:workflow_state) { described_class.create name: 'test', workflow_id: 'abc123' }
+      let!(:entity)        { Sipity::Entity.create(workflow_state: workflow_state, proxy_for_global_id: "abc123", workflow_id: workflow_state.workflow_id) }
+      it "has entites" do
+        expect(workflow_state.entities).to match_array([entity])
+      end
+    end
+  end
+end

data/spec/models/solr_document_spec.rb

@@ -0,0 +1,159 @@
+describe ::SolrDocument, type: :model do
+  let(:document) { described_class.new(attributes) }
+  let(:attributes) { {} }
+
+  describe "#itemtype" do
+    let(:attributes) { { resource_type_tesim: ['Article'] } }
+    it "delegates to the Hyrax::ResourceTypesService" do
+      expect(Hyrax::ResourceTypesService).to receive(:microdata_type).with('Article')
+      subject
+    end
+    subject { document.itemtype }
+    it { is_expected.to eq 'http://schema.org/Article' }
+  end
+
+  describe "date_uploaded" do
+    let(:attributes) { { 'date_uploaded_dtsi' => '2013-03-14T00:00:00Z' } }
+    subject { document.date_uploaded }
+    it { is_expected.to eq '03/14/2013' }
+
+    context "when an invalid type is provided" do
+      let(:attributes) { { 'date_uploaded_dtsi' => 'Test' } }
+      it "logs parse errors" do
+        expect(ActiveFedora::Base.logger).to receive(:info).with(/Unable to parse date.*/)
+        subject
+      end
+    end
+  end
+
+  describe "create_date" do
+    let(:attributes) { { 'system_create_dtsi' => '2013-03-14T00:00:00Z' } }
+    subject { document.create_date }
+    it { is_expected.to eq '03/14/2013' }
+
+    context "when an invalid type is provided" do
+      let(:attributes) { { 'system_create_dtsi' => 'Test' } }
+      it "logs parse errors" do
+        expect(ActiveFedora::Base.logger).to receive(:info).with(/Unable to parse date.*/)
+        subject
+      end
+    end
+  end
+
+  describe "resource_type" do
+    let(:attributes) { { 'resource_type_tesim' => ['Image'] } }
+    subject { document.resource_type }
+    it { is_expected.to eq ['Image'] }
+  end
+
+  describe '#to_param' do
+    let(:id) { '1v53kn56d' }
+    let(:attributes) { { id: id } }
+    subject { document.to_param }
+    it { is_expected.to eq id }
+  end
+
+  describe "#suppressed?" do
+    let(:attributes) { { 'suppressed_bsi' => suppressed_value } }
+    subject { document }
+    context 'when true' do
+      let(:suppressed_value) { true }
+      it { is_expected.to be_suppressed }
+    end
+    context 'when false' do
+      let(:suppressed_value) { false }
+      it { is_expected.not_to be_suppressed }
+    end
+  end
+  describe "document types" do
+    class Mimes
+      include Hydra::Works::MimeTypes
+    end
+
+    Mimes.office_document_mime_types.each do |type|
+      context "when mime-type is #{type}" do
+        let(:attributes) { { 'mime_type_ssi' => type } }
+        subject { document }
+        it { is_expected.to be_office_document }
+      end
+    end
+
+    Mimes.video_mime_types.each do |type|
+      context "when mime-type is #{type}" do
+        let(:attributes) { { 'mime_type_ssi' => type } }
+        subject { document }
+        it { is_expected.to be_video }
+      end
+    end
+  end
+
+  describe '#collection_ids' do
+    subject { document.collection_ids }
+    context 'when the object belongs to collections' do
+      let(:attributes) do
+        { id: '123',
+          title_tesim: ['A generic work'],
+          collection_ids_tesim: ['123', '456', '789'] }
+      end
+      it { is_expected.to eq ['123', '456', '789'] }
+    end
+
+    context 'when the object does not belong to any collections' do
+      let(:attributes) do
+        { id: '123',
+          title_tesim: ['A generic work'] }
+      end
+
+      it { is_expected.to eq [] }
+    end
+  end
+
+  describe '#collections' do
+    subject { document.collections }
+    context 'when the object belongs to a collection' do
+      let(:coll_id) { '456' }
+      let(:attributes) do
+        { id: '123',
+          title_tesim: ['A generic work'],
+          collection_ids_tesim: [coll_id] }
+      end
+
+      let(:coll_attrs) { { id: coll_id, title_tesim: ['A Collection'] } }
+
+      before do
+        ActiveFedora::SolrService.add(coll_attrs)
+        ActiveFedora::SolrService.commit
+      end
+
+      it 'returns the solr docs for the collections' do
+        expect(subject.count).to eq 1
+        solr_doc = subject.first
+        expect(solr_doc).to be_kind_of described_class
+        expect(solr_doc['id']).to eq coll_id
+        expect(solr_doc['title_tesim']).to eq coll_attrs[:title_tesim]
+      end
+    end
+
+    context 'when the object does not belong to any collections' do
+      it { is_expected.to eq [] }
+    end
+  end
+
+  describe "#height" do
+    let(:attributes) { { height_is: '444' } }
+    subject { document.height }
+    it { is_expected.to eq '444' }
+  end
+
+  describe "#width" do
+    let(:attributes) { { width_is: '555' } }
+    subject { document.width }
+    it { is_expected.to eq '555' }
+  end
+
+  context "when exporting in endnote format" do
+    let(:attributes) { { id: "1234" } }
+    subject { document.endnote_filename }
+    it { is_expected.to eq("1234.endnote") }
+  end
+end

data/spec/models/trophy_spec.rb

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,60 @@
+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 "#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

@@ -0,0 +1,203 @@
+describe User, type: :model do
+  let(:user) { FactoryGirl.build(:user) }
+  let(:another_user) { FactoryGirl.build(:user) }
+
+  describe 'verifying factories' do
+    describe ':user' do
+      let(:user) { FactoryGirl.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 = FactoryGirl.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) { FactoryGirl.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 URI 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 'normalizes bare ORCIDs to URIs' do
+      user.orcid = '0000-0000-1111-2222'
+      user.save
+      expect(user.orcid).to eq 'http://orcid.org/0000-0000-1111-2222'
+    end
+    it 'marks bad ORCIDs as invalid' do
+      user.orcid = '000-000-111-222'
+      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
+    it 'will find or create a Sipity::Agent' do
+      user.save!
+      expect { user.to_sipity_agent }.to change { Sipity::Agent.count }.by(1)
+    end
+
+    it 'will fail if the User is not persisted' do
+      expect { user.to_sipity_agent }.to raise_error(ActiveRecord::StatementInvalid)
+    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
+end