sufia 6.2.0 → 6.3.0

data/spec/models/geo_names_resource_spec.rb

@@ -1,10 +1,8 @@
 require 'spec_helper'
 
-describe GeoNamesResource, :type => :model do
-
-  it "should find locations" do
-    hits = GeoNamesResource.find_location("State")
+describe GeoNamesResource, type: :model do
+  it "finds locations" do
+    hits = described_class.find_location("State")
     expect(hits).not_to be_nil
   end
 end
-

data/spec/models/local_authority_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
-describe LocalAuthority, :type => :model do
-
+describe LocalAuthority, type: :model do
   def harvest_nt
     LocalAuthority.harvest_rdf("genres", [fixture_path + '/genreForms.nt'])
   end
@@ -18,29 +17,28 @@ describe LocalAuthority, :type => :model do
     Object.send(:remove_const, :MyTestRdfDatastream)
   end
 
-  it "should harvest an ntriples RDF vocab" do
+  it "harvests an ntriples RDF vocab" do
     harvest_nt
-    expect(LocalAuthority.count).to eq(1)
+    expect(described_class.count).to eq(1)
     expect(LocalAuthorityEntry.count).to eq(6)
   end
-  it "should harvest an RDF/XML vocab (w/ an alt predicate)" do
-    LocalAuthority.harvest_rdf("langs", [fixture_path + '/lexvo.rdf'],
-                               format: 'rdfxml',
-                               predicate: ::RDF::URI("http://www.w3.org/2008/05/skos#prefLabel"))
-    expect(LocalAuthority.count).to eq(1)
+  it "harvests an RDF/XML vocab (w/ an alt predicate)" do
+    described_class.harvest_rdf("langs", [fixture_path + '/lexvo.rdf'],
+                                format: 'rdfxml',
+                                predicate: ::RDF::URI("http://www.w3.org/2008/05/skos#prefLabel"))
+    expect(described_class.count).to eq(1)
     expect(LocalAuthorityEntry.count).to eq(35)
   end
-  it "should harvest TSV vocabs" do
+  it "harvests TSV vocabs" do
     harvest_tsv
-    expect(LocalAuthority.count).to eq(1)
-    auth = LocalAuthority.where(name: "geo").first
+    expect(described_class.count).to eq(1)
+    auth = described_class.where(name: "geo").first
     expect(LocalAuthorityEntry.where(local_authority_id: auth.id).first.uri).to start_with('http://sws.geonames.org/')
     expect(LocalAuthorityEntry.count).to eq(149)
   end
 
   describe "when vocabs are harvested" do
-
-    let(:num_auths)   { LocalAuthority.count }
+    let(:num_auths)   { described_class.count }
     let(:num_entries) { LocalAuthorityEntry.count }
 
     before do
@@ -48,50 +46,49 @@ describe LocalAuthority, :type => :model do
       harvest_tsv
     end
 
-    it "should not have any initial domain terms" do
+    it "does not have any initial domain terms" do
       expect(DomainTerm.count).to eq(0)
     end
 
-    it "should not harvest an RDF vocab twice" do
+    it "does not harvest an RDF vocab twice" do
       harvest_nt
-      expect(LocalAuthority.count).to eq(num_auths)
+      expect(described_class.count).to eq(num_auths)
       expect(LocalAuthorityEntry.count).to eq(num_entries)
     end
-    it "should not harvest a TSV vocab twice" do
+    it "does not harvest a TSV vocab twice" do
       harvest_tsv
-      expect(LocalAuthority.count).to eq(num_auths)
+      expect(described_class.count).to eq(num_auths)
       expect(LocalAuthorityEntry.count).to eq(num_entries)
     end
-    it "should register a vocab" do
-      LocalAuthority.register_vocabulary(MyTestRdfDatastream, "geographic", "geo")
+    it "registers a vocab" do
+      described_class.register_vocabulary(MyTestRdfDatastream, "geographic", "geo")
       expect(DomainTerm.count).to eq(1)
     end
 
     describe "when vocabs are registered" do
-
       before do
-        LocalAuthority.register_vocabulary(MyTestRdfDatastream, "geographic", "geo")
-        LocalAuthority.register_vocabulary(MyTestRdfDatastream, "genre", "genres")
+        described_class.register_vocabulary(MyTestRdfDatastream, "geographic", "geo")
+        described_class.register_vocabulary(MyTestRdfDatastream, "genre", "genres")
       end
 
-      it "should have some doamin terms" do
+      it "has some doamin terms" do
         expect(DomainTerm.count).to eq(2)
       end
 
-      it "should return nil for empty queries" do
-        expect(LocalAuthority.entries_by_term("my_test", "geographic", "")).to be_nil
+      it "returns nil for empty queries" do
+        expect(described_class.entries_by_term("my_test", "geographic", "")).to be_nil
       end
-      it "should return an empty array for unregistered models" do
-        expect(LocalAuthority.entries_by_term("my_foobar", "geographic", "E")).to eq([])
+      it "returns an empty array for unregistered models" do
+        expect(described_class.entries_by_term("my_foobar", "geographic", "E")).to eq([])
       end
-      it "should return an empty array for unregistered terms" do
-        expect(LocalAuthority.entries_by_term("my_test", "foobar", "E")).to eq([])
+      it "returns an empty array for unregistered terms" do
+        expect(described_class.entries_by_term("my_test", "foobar", "E")).to eq([])
       end
-      it "should return entries by term" do
+      it "returns entries by term" do
         term = DomainTerm.where(model: "my_tests", term: "genre").first
         authorities = term.local_authorities.collect(&:id).uniq
         LocalAuthorityEntry.where("local_authority_id in (?)", authorities).where("label like ?", "A%").select("label, uri").limit(25)
-        expect(LocalAuthority.entries_by_term("my_tests", "genre", "A").count).to eq(6)
+        expect(described_class.entries_by_term("my_tests", "genre", "A").count).to eq(6)
       end
     end
   end

data/spec/models/pageview_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-describe Sufia::Pageview, :type => :model do
+describe Sufia::Pageview, type: :model do
   before do
-    @pageview = Sufia::Pageview
+    @pageview = described_class
   end
 
   it 'has a pageviews metric' do
-    expect(@pageview.metrics).to be  == Legato::ListParameter.new(:metrics, [:pageviews])
+    expect(@pageview.metrics).to be == Legato::ListParameter.new(:metrics, [:pageviews])
   end
 
   it 'has a date dimension' do

data/spec/models/proxy_deposit_request_spec.rb

@@ -13,8 +13,8 @@ describe ProxyDepositRequest, type: :model do
   end
 
   subject do
-    ProxyDepositRequest.new(generic_file_id: file.id, sending_user: sender,
-      receiving_user: receiver, sender_comment: "please take this")
+    described_class.new(generic_file_id: file.id, sending_user: sender,
+                        receiving_user: receiver, sender_comment: "please take this")
   end
 
   its(:status) { is_expected.to eq 'pending' }
@@ -92,7 +92,7 @@ describe ProxyDepositRequest, type: :model do
     end
 
     context 'when the file is already being transferred' do
-      let(:subject2) {ProxyDepositRequest.new(generic_file_id: file.id, sending_user: sender, receiving_user: receiver2, sender_comment: 'please take this')}
+      let(:subject2) { described_class.new(generic_file_id: file.id, sending_user: sender, receiving_user: receiver2, sender_comment: 'please take this') }
 
       it 'raises an error' do
         subject.save!

data/spec/models/single_use_link_spec.rb

@@ -10,56 +10,56 @@ describe SingleUseLink do
   let(:file) { @file }
 
   describe "create" do
-     before do
+    before do
       @now = DateTime.now
       allow(DateTime).to receive(:now).and_return(@now)
-      @hash = "sha2hash#{@now.to_f.to_s}"
+      @hash = "sha2hash#{@now.to_f}"
       expect(Digest::SHA2).to receive(:new).and_return(@hash)
-     end
-     it "should create show link" do
-      su = SingleUseLink.create itemId: file.id, path: Sufia::Engine.routes.url_helpers.generic_file_path(file.id)
+    end
+    it "creates show link" do
+      su = described_class.create itemId: file.id, path: Sufia::Engine.routes.url_helpers.generic_file_path(file.id)
       expect(su.downloadKey).to eq(@hash)
       expect(su.itemId).to eq(file.id)
       expect(su.path).to eq(Sufia::Engine.routes.url_helpers.generic_file_path(file.id))
       su.delete
-     end
-     it "should create show download link" do
-      su = SingleUseLink.create itemId: file.id, path: Sufia::Engine.routes.url_helpers.download_path(file.id)
+    end
+    it "creates show download link" do
+      su = described_class.create itemId: file.id, path: Sufia::Engine.routes.url_helpers.download_path(file.id)
       expect(su.downloadKey).to eq(@hash)
       expect(su.itemId).to eq(file.id)
       expect(su.path).to eq(Sufia::Engine.routes.url_helpers.download_path(file.id))
       su.delete
-     end
+    end
   end
   describe "find" do
-     describe "not expired" do
-       before do
-          @su = SingleUseLink.create(downloadKey: 'sha2hashb', itemId: file.id, path: Sufia::Engine.routes.url_helpers.download_path(file), expires: DateTime.now.advance(hours: 1))
-       end
-       it "should retrieve link" do
-          link = SingleUseLink.where(downloadKey: 'sha2hashb').first
-          expect(link.itemId).to eq(file.id)
-       end
-       it "should retrieve link with find_by" do
-          link = SingleUseLink.find_by_downloadKey('sha2hashb')
-          expect(link.itemId).to eq(file.id)
-       end
-       it "should expire link" do
-          link = SingleUseLink.where(downloadKey: 'sha2hashb').first
-          expect(link.expired?).to eq(false)
-       end
-     end
-     describe "expired" do
-       before do
-          @su = SingleUseLink.create!(downloadKey: 'sha2hashb', itemId:file.id, path:Sufia::Engine.routes.url_helpers.download_path(file))
+    describe "not expired" do
+      before do
+        @su = described_class.create(downloadKey: 'sha2hashb', itemId: file.id, path: Sufia::Engine.routes.url_helpers.download_path(file), expires: DateTime.now.advance(hours: 1))
+      end
+      it "retrieves link" do
+        link = described_class.where(downloadKey: 'sha2hashb').first
+        expect(link.itemId).to eq(file.id)
+      end
+      it "retrieves link with find_by" do
+        link = described_class.find_by_downloadKey('sha2hashb')
+        expect(link.itemId).to eq(file.id)
+      end
+      it "expires link" do
+        link = described_class.where(downloadKey: 'sha2hashb').first
+        expect(link.expired?).to eq(false)
+      end
+    end
+    describe "expired" do
+      before do
+        @su = described_class.create!(downloadKey: 'sha2hashb', itemId: file.id, path: Sufia::Engine.routes.url_helpers.download_path(file))
 
-          @su.update_attribute :expires, DateTime.now.advance(hours: -1)
-       end
+        @su.update_attribute :expires, DateTime.now.advance(hours: -1)
+      end
 
-       it "should expire link" do
-          link = SingleUseLink.where(downloadKey: 'sha2hashb').first
-          expect(link.expired?).to eq(true)
-       end
-     end
+      it "expires link" do
+        link = described_class.where(downloadKey: 'sha2hashb').first
+        expect(link.expired?).to eq(true)
+      end
+    end
   end
 end

data/spec/models/solr_document_spec.rb

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
 describe SolrDocument, type: :model do
-
   describe "date_uploaded" do
     before do
       subject['date_uploaded_dtsi'] = '2013-03-14T00:00:00Z'
     end
-    it "should be a date" do
+    it "is a date" do
       expect(subject.date_uploaded).to eq '03/14/2013'
     end
   end
@@ -29,7 +28,7 @@ describe SolrDocument, type: :model do
     end
 
     context "when mime-type is 'office'" do
-      it "should be office document" do
+      it "is office document" do
         Mimes.office_document_mime_types.each do |type|
           subject['mime_type_tesim'] = [type]
           expect(subject).to be_office_document
@@ -38,14 +37,12 @@ describe SolrDocument, type: :model do
     end
 
     describe "when mime-type is 'video'" do
-      it "should be office" do
+      it "is office" do
         Mimes.video_mime_types.each do |type|
           subject['mime_type_tesim'] = [type]
           expect(subject).to be_video
         end
       end
     end
-
   end
-
 end

data/spec/models/trophy_spec.rb

@@ -1,24 +1,23 @@
 require 'spec_helper'
 
-describe Trophy, :type => :model do
+describe Trophy, type: :model do
   before(:all) do
-    @trophy = Trophy.create(user_id:99,generic_file_id:"99")
+    @trophy = described_class.create(user_id: 99, generic_file_id: "99")
   end
 
-  it "should have a user" do
+  it "has a user" do
     expect(@trophy).to respond_to(:user_id)
     expect(@trophy.user_id).to eq(99)
   end
 
-  it "should have a file" do
+  it "has a file" do
     expect(@trophy).to respond_to(:generic_file_id)
     expect(@trophy.generic_file_id).to eq("99")
   end
 
-  it "should not allow six trophies" do
-    (1..6).each { |n| Trophy.create(user_id:120,generic_file_id:n.to_s) }
-    expect(Trophy.where(user_id:120).count).to eq(5)
-    Trophy.where(user_id:120).map(&:delete)
+  it "does not allow six trophies" do
+    (1..6).each { |n| described_class.create(user_id: 120, generic_file_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,62 @@
+require 'spec_helper'
+
+describe UserMailbox do
+  let(:user)         { FactoryGirl.find_or_create(:jill) }
+  let(:another_user) { FactoryGirl.find_or_create(:archivist) }
+  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)     { FactoryGirl.find_or_create(:curator) }
+      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,13 +1,13 @@
 require 'spec_helper'
 
-describe User, :type => :model do
+describe User, type: :model do
   let(:user) { FactoryGirl.build(:user) }
   let(:another_user) { FactoryGirl.build(:user) }
 
-  it "should have an email" do
+  it "has an email" do
     expect(user.user_key).to be_kind_of String
   end
-  it "should have activity stream-related methods defined" do
+  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)
@@ -15,7 +15,7 @@ describe User, :type => :model do
     expect(user).to respond_to(:log_event)
     expect(user).to respond_to(:log_profile_event)
   end
-  it "should have social attributes" do
+  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)
@@ -25,7 +25,7 @@ describe User, :type => :model do
 
   describe 'Arkivo and Zotero integration' do
     it 'sets an Arkivo token after_initialize if API is enabled' do
-      expect(User.new).to respond_to(:arkivo_token)
+      expect(described_class.new).to respond_to(:arkivo_token)
     end
 
     describe 'Arkivo token generation' do
@@ -37,9 +37,9 @@ describe User, :type => :model do
       let(:token2) { 'token2' }
 
       it 'generates a new token if a user is found with the existing token' do
-        user1 = User.create(email: 'foo@example.org', password: 'foobarbaz')
+        user1 = described_class.create(email: 'foo@example.org', password: 'foobarbaz')
         expect(user1.arkivo_token).to eq token1
-        user2 = User.create(email: 'bar@example.org', password: 'bazquuxquuux')
+        user2 = described_class.create(email: 'bar@example.org', password: 'bazquuxquuux')
         expect(user2.arkivo_token).to eq token2
       end
     end
@@ -49,7 +49,7 @@ describe User, :type => :model do
 
       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.read_attribute(:zotero_token)).to eq Marshal.dump(token)
         expect(user.zotero_token).to eq token
       end
     end
@@ -84,17 +84,17 @@ describe User, :type => :model do
   end
 
   describe "#to_param" do
-    let(:user) { User.new(email: 'jilluser@example.com') }
+    let(:user) { described_class.new(email: 'jilluser@example.com') }
 
-    it "should override to_param to make keys more recognizable in redis (and useable within Rails URLs)" do
+    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
 
-  it "should have a cancan ability defined" do
+  it "has a cancan ability defined" do
     expect(user).to respond_to(:can?)
   end
-  it "should not have any followers" do
+  it "does not have any followers" do
     expect(user.followers_count).to eq(0)
     expect(another_user.follow_count).to eq(0)
   end
@@ -105,13 +105,13 @@ describe User, :type => :model do
       user.follow(another_user)
     end
 
-    it "should be able to follow another user" do
+    it "is able to follow another user" do
       expect(user).to be_following(another_user)
       expect(another_user).to_not be_following(user)
       expect(another_user).to be_followed_by(user)
       expect(user).to_not be_followed_by(another_user)
     end
-    it "should be able to unfollow another user" do
+    it "is able to unfollow another user" do
       user.stop_following(another_user)
       expect(user).to_not be_following(another_user)
       expect(another_user).to_not be_followed_by(user)
@@ -127,21 +127,20 @@ describe User, :type => :model do
     let!(:trophy2) { user.trophies.create!(generic_file_id: file2.id) }
     let!(:trophy3) { user.trophies.create!(generic_file_id: file3.id) }
 
-    it "should return a list of generic files" do
+    it "returns a list of generic files" do
       expect(user.trophy_files).to eq [file1, file2, file3]
     end
-
   end
 
   describe "activity streams" do
     let(:now) { DateTime.now.to_i }
-    let(:activities) {
-        [{ action: 'so and so edited their profile', timestamp: now },
-        { action: 'so and so uploaded a file', timestamp: (now - 360 ) }]
-    }
-    let(:file_activities) {
+    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)
@@ -149,11 +148,11 @@ describe User, :type => :model do
     end
 
     it "gathers the user's recent activity within the default amount of time" do
-      expect(user.get_all_user_activity).to eq(file_activities.concat(activities))
+      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.get_all_user_activity(now-60)).to eq(file_activities.concat([activities.first]))
+      expect(user.all_user_activity(now - 60)).to eq(file_activities.concat([activities.first]))
     end
   end
   describe "proxy_deposit_rights" do
@@ -174,23 +173,23 @@ describe User, :type => :model do
   end
   describe "class methods" do
     describe "recent_users" do
-      let(:new_users) { User.all.order(created_at: :desc) }
+      let(:new_users) { described_class.all.order(created_at: :desc) }
 
       before do
-        (1..3).each {|i| User.create(email: "abc#{i}@blah.frg", password: "blarg1234", created_at:DateTime.now - i.days) }
+        (1..3).each { |i| described_class.create(email: "abc#{i}@blah.frg", password: "blarg1234", created_at: DateTime.now - i.days) }
       end
 
       context "when has a start date" do
-        subject { User.recent_users(Date.today - 2.days) }
+        subject { described_class.recent_users(Date.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.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 { User.recent_users(Date.today - 2.days, Date.today - 1.days) }
+        subject { described_class.recent_users(Date.today - 2.days, Date.today - 1.days) }
         it "returns valid data" do
           expect(subject.count).to eq 1
           is_expected.to include(new_users[1])