sufia 4.0.1 → 4.1.0

data/spec/models/geo_names_resource_spec.rb

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

data/spec/models/local_authority_spec.rb

@@ -1,102 +1,103 @@
 require 'spec_helper'
 
-# Don't run the tests if activerecord-import isn't installed.
-# The 0.3.1 version doesn't work with rails 4, so suppress these tests
-describe LocalAuthority do
-  before(:all) do
-    @tsv = [fixture_path + '/cities15000.tsv']
-    @nt = [fixture_path + '/genreForms.nt']
-    @rdfxml = [fixture_path + '/lexvo.rdf']
-    LocalAuthority.count.should == 0
-    LocalAuthorityEntry.count.should == 0
+describe LocalAuthority, :type => :model do
+
+  def harvest_nt
+    LocalAuthority.harvest_rdf("genres", [fixture_path + '/genreForms.nt'])
   end
-  after(:each) do
-    LocalAuthorityEntry.all.each(&:destroy)
-    DomainTerm.all.each do |term|
-      term.local_authorities.each do |auth|
-        auth.destroy
-      end
-      term.destroy
-    end
+
+  def harvest_tsv
+    LocalAuthority.harvest_tsv("geo", [fixture_path + '/cities15000.tsv'], prefix: 'http://sws.geonames.org/')
+  end
+
+  before :all do
+    class MyTestRdfDatastream; end
+  end
+  after :all do
+    Object.send(:remove_const, :MyTestRdfDatastream)
+  end
+  after do
+    DomainTerm.destroy_all
+    LocalAuthority.destroy_all
+    LocalAuthorityEntry.destroy_all
   end
+  
   it "should harvest an ntriples RDF vocab" do
-    LocalAuthority.harvest_rdf("genres", @nt)
-    LocalAuthority.count.should == 1
-    LocalAuthorityEntry.count.should == 6
+    harvest_nt
+    expect(LocalAuthority.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", @rdfxml, 
+    LocalAuthority.harvest_rdf("langs", [fixture_path + '/lexvo.rdf'],
                                format: 'rdfxml',
                                predicate: RDF::URI("http://www.w3.org/2008/05/skos#prefLabel"))
-    LocalAuthority.count.should == 1
-    LocalAuthorityEntry.count.should == 35
+    expect(LocalAuthority.count).to eq(1)
+    expect(LocalAuthorityEntry.count).to eq(35)
   end
   it "should harvest TSV vocabs" do
-    LocalAuthority.harvest_tsv("geo", @tsv, prefix: 'http://sws.geonames.org/')
-    LocalAuthority.count.should == 1
+    harvest_tsv
+    expect(LocalAuthority.count).to eq(1)
     auth = LocalAuthority.where(name: "geo").first
     expect(LocalAuthorityEntry.where(local_authority_id: auth.id).first.uri).to start_with('http://sws.geonames.org/')
-    LocalAuthorityEntry.count.should == 149
+    expect(LocalAuthorityEntry.count).to eq(149)
   end
+  
   describe "when vocabs are harvested" do
-    before(:all) do
-      class MyTestRdfDatastream; end
-      LocalAuthority.harvest_rdf("genres", @nt)
-      LocalAuthority.harvest_tsv("geo", @tsv, prefix: 'http://sws.geonames.org/')
-      DomainTerm.count.should == 0
-      @num_auths = LocalAuthority.count
-      @num_entries = LocalAuthorityEntry.count
+    
+    let(:num_auths)   { LocalAuthority.count }
+    let(:num_entries) { LocalAuthorityEntry.count }
+
+    before do
+      harvest_nt
+      harvest_tsv
     end
-    after(:all) do
-      DomainTerm.all.each(&:delete)
-      LocalAuthority.all.each(&:delete)
-      LocalAuthorityEntry.all.each(&:delete)
-      Object.send(:remove_const, :MyTestRdfDatastream)
+
+    it "should not have any initial domain terms" do
+      expect(DomainTerm.count).to eq(0)
     end
+
     it "should not harvest an RDF vocab twice" do
-      LocalAuthority.harvest_rdf("genres", @nt)
-      LocalAuthority.count.should == @num_auths
-      LocalAuthorityEntry.count.should == @num_entries
+      harvest_nt
+      expect(LocalAuthority.count).to eq(num_auths)
+      expect(LocalAuthorityEntry.count).to eq(num_entries)
     end
     it "should not harvest a TSV vocab twice" do
-      LocalAuthority.harvest_tsv("geo", @tsv, prefix: 'http://sws.geonames.org/')
-      LocalAuthority.count.should == @num_auths
-      LocalAuthorityEntry.count.should == @num_entries
+      harvest_tsv
+      expect(LocalAuthority.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")
-      DomainTerm.count.should == 1
+      expect(DomainTerm.count).to eq(1)
     end
+    
     describe "when vocabs are registered" do
-      before(:all) do
-        LocalAuthority.harvest_rdf("genres", @nt)
-        LocalAuthority.harvest_tsv("geo", @tsv, prefix: 'http://sws.geonames.org/')
-        class TestRdfDatastream; end
+      
+      before do
         LocalAuthority.register_vocabulary(MyTestRdfDatastream, "geographic", "geo")
         LocalAuthority.register_vocabulary(MyTestRdfDatastream, "genre", "genres")
-        DomainTerm.count.should == 2
       end
-      after(:all) do
-        DomainTerm.all.each(&:delete)
-        LocalAuthority.all.each(&:delete)
-        LocalAuthorityEntry.all.each(&:delete)
+
+      it "should have some doamin terms" do
+        expect(DomainTerm.count).to eq(2)
       end
+      
       it "should return nil for empty queries" do
-        LocalAuthority.entries_by_term("my_test", "geographic", "").should be_nil
+        expect(LocalAuthority.entries_by_term("my_test", "geographic", "")).to be_nil
       end
       it "should return an empty array for unregistered models" do
-        LocalAuthority.entries_by_term("my_foobar", "geographic", "E").should == []
+        expect(LocalAuthority.entries_by_term("my_foobar", "geographic", "E")).to eq([])
       end
       it "should return an empty array for unregistered terms" do
-        LocalAuthority.entries_by_term("my_test", "foobar", "E").should == []
+        expect(LocalAuthority.entries_by_term("my_test", "foobar", "E")).to eq([])
       end
       it "should return entries by term" do
         term = DomainTerm.where(model: "my_tests", term: "genre").first
         authorities = term.local_authorities.collect(&:id).uniq
         hits = LocalAuthorityEntry.where("local_authority_id in (?)", authorities).where("label like ?", "A%").select("label, uri").limit(25)
-        LocalAuthority.entries_by_term("my_tests", "genre", "A").count.should == 6
+        expect(LocalAuthority.entries_by_term("my_tests", "genre", "A").count).to eq(6)
       end
+   
     end
   end
 end
-    

data/spec/models/pageview_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Sufia::Pageview do
+describe Sufia::Pageview, :type => :model do
   before do
     @pageview = Sufia::Pageview
   end

data/spec/models/properties_datastream_spec.rb

@@ -1,22 +1,41 @@
 require 'spec_helper'
 
-describe PropertiesDatastream do
+describe PropertiesDatastream, :type => :model do
+  describe "import_url" do
+    before do
+      subject.import_url = 'http://example.com/somefile.txt'
+    end
 
-  it "should have import_url" do
-    subject.import_url = 'http://example.com/somefile.txt'
-    subject.import_url.should == ['http://example.com/somefile.txt']
-    subject.ng_xml.to_xml.should be_equivalent_to "<?xml version=\"1.0\"?><fields><importUrl>http://example.com/somefile.txt</importUrl></fields>"
+    it "serializes" do
+      expect(subject.import_url).to eq ['http://example.com/somefile.txt']
+      expect(subject.ng_xml.to_xml).to be_equivalent_to "<?xml version=\"1.0\"?><fields><importUrl>http://example.com/somefile.txt</importUrl></fields>"
+    end
   end
 
-  describe "to_solr" do
+  describe "proxy_depositor" do
     before do
-      @doc = PropertiesDatastream.new(nil, 'properties').tap do |ds|
+      subject.proxy_depositor = 'kim@example.com'
+    end
+
+    it "serializes proxy_depositor" do
+      expect(subject.proxy_depositor).to eq ['kim@example.com']
+      expect(subject.ng_xml.to_xml).to be_equivalent_to "<?xml version=\"1.0\"?><fields><proxyDepositor>kim@example.com</proxyDepositor></fields>"
+    end
+  end
+
+  describe "to_solr" do
+    let(:doc) {
+      PropertiesDatastream.new(nil, 'properties').tap do |ds|
         ds.import_url = 'http://example.com/somefile.txt'
+        ds.proxy_depositor = 'kim@example.com'
       end
+    }
+    subject { doc.to_solr}
+    it "solrizes import_url" do
+      expect(subject['import_url_ssim']).to eq ['http://example.com/somefile.txt']
     end
-    subject { @doc.to_solr}
-    it "should have import_url" do
-      subject['import_url_ssim'].should == ['http://example.com/somefile.txt']
+    it "solrizes proxy_depositor" do
+      expect(subject['proxy_depositor_ssim']).to eq ['kim@example.com']
     end
   end
 end

data/spec/models/proxy_deposit_request_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe ProxyDepositRequest, type: :model do
+  let(:sender) { FactoryGirl.find_or_create(:jill) }
+  let(:receiver) { FactoryGirl.find_or_create(:archivist) }
+  let(:receiver2) { FactoryGirl.find_or_create(:curator) }
+  let(:file) do
+    GenericFile.new.tap do |f|
+      f.title = ["Test file"]
+      f.apply_depositor_metadata(sender.user_key)
+      f.save!
+    end
+  end
+
+  subject do
+    ProxyDepositRequest.new(pid: file.pid, sending_user: sender,
+      receiving_user: receiver, sender_comment: "please take this")
+  end
+
+  after do
+    subject.destroy if subject.persisted?
+  end
+
+  its(:status) { is_expected.to eq 'pending' }
+  it { is_expected.to be_pending }
+  its(:fulfillment_date) { is_expected.to be_nil }
+  its(:sender_comment) { is_expected.to eq 'please take this' }
+
+  it "has a title for the file" do
+    expect(subject.title).to eq('Test file')
+  end
+
+  context "After approval" do
+    before do
+      subject.transfer!
+    end
+
+    its(:status) { is_expected.to eq 'accepted' }
+    its(:fulfillment_date) { is_expected.not_to be_nil }
+    its(:deleted_file?) { is_expected.to be false }
+
+    describe "and the file is deleted" do
+      before do
+        file.destroy
+      end
+
+      its(:title) { is_expected.to eq 'file not found' }
+      its(:deleted_file?) { is_expected.to be true }
+    end
+  end
+
+  context "After rejection" do
+    before do
+      subject.reject!('a comment')
+    end
+
+    its(:status) { is_expected.to eq 'rejected' }
+    its(:fulfillment_date) { is_expected.not_to be_nil }
+    its(:receiver_comment) { is_expected.to eq 'a comment' }
+  end
+
+  context "After cancel" do
+    before do
+      subject.cancel!
+    end
+
+    its(:status) { is_expected.to eq 'canceled' }
+    its(:fulfillment_date) { is_expected.not_to be_nil }
+   end
+
+  describe 'transfer' do
+    context 'when the transfer_to user is not found' do
+      it 'raises an error' do
+        subject.transfer_to = 'dave'
+        expect(subject).not_to be_valid
+        expect(subject.errors[:transfer_to]).to eq(['must be an existing user'])
+      end
+    end
+
+    context 'when the transfer_to user is found' do
+      it 'creates a transfer_request' do
+        subject.transfer_to = receiver.user_key
+        subject.save!
+        proxy_request = receiver.proxy_deposit_requests.first
+        expect(proxy_request.pid).to eq(file.pid)
+        expect(proxy_request.sending_user).to eq(sender)
+      end
+    end
+
+    context 'when the receiving user is the sending user' do
+      it 'raises an error' do
+        subject.transfer_to = sender.user_key
+        expect(subject).not_to be_valid
+        expect(subject.errors[:sending_user]).to eq(['must specify another user to receive the file'])
+      end
+    end
+
+    context 'when the file is already being transferred' do
+      it 'raises an error' do
+        subject.save!
+        subject2 = ProxyDepositRequest.new(pid: file.pid, sending_user: sender, receiving_user: receiver2, sender_comment: 'please take this')
+        expect(subject2).not_to be_valid
+        expect(subject2.errors[:open_transfer]).to eq(['must close open transfer on the file before creating a new one'])
+      end
+    end
+  end
+end

data/spec/models/single_use_link_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe SingleUseLink do
+describe SingleUseLink, :type => :model do
   before(:all) do
     @file = GenericFile.new
     @file.apply_depositor_metadata('mjg36')
@@ -16,22 +16,22 @@ describe SingleUseLink do
   describe "create" do
      before do
       @now = DateTime.now
-      DateTime.stub(:now).and_return(@now)
+      allow(DateTime).to receive(:now).and_return(@now)
       @hash = "sha2hash#{@now.to_f.to_s}"
-      Digest::SHA2.should_receive(:new).and_return(@hash)
+      expect(Digest::SHA2).to receive(:new).and_return(@hash)
      end
      it "should create show link" do
       su = SingleUseLink.create itemId: file.pid, path: Sufia::Engine.routes.url_helpers.generic_file_path(file.pid)
-      su.downloadKey.should == @hash
-      su.itemId.should == file.pid
-      su.path.should == Sufia::Engine.routes.url_helpers.generic_file_path(file.pid)
+      expect(su.downloadKey).to eq(@hash)
+      expect(su.itemId).to eq(file.pid)
+      expect(su.path).to eq(Sufia::Engine.routes.url_helpers.generic_file_path(file.pid))
       su.delete
      end
      it "should create show download link" do
       su = SingleUseLink.create itemId: file.pid, path: Sufia::Engine.routes.url_helpers.download_path(file.pid)
-      su.downloadKey.should == @hash
-      su.itemId.should == file.pid
-      su.path.should == Sufia::Engine.routes.url_helpers.download_path(file.pid)
+      expect(su.downloadKey).to eq(@hash)
+      expect(su.itemId).to eq(file.pid)
+      expect(su.path).to eq(Sufia::Engine.routes.url_helpers.download_path(file.pid))
       su.delete
      end
   end
@@ -42,15 +42,15 @@ describe SingleUseLink do
        end
        it "should retrieve link" do
           link = SingleUseLink.where(downloadKey: 'sha2hashb').first
-          link.itemId.should == file.pid
+          expect(link.itemId).to eq(file.pid)
        end
        it "should retrieve link with find_by" do
           link = SingleUseLink.find_by_downloadKey('sha2hashb')
-          link.itemId.should == file.pid
+          expect(link.itemId).to eq(file.pid)
        end
        it "should expire link" do
           link = SingleUseLink.where(downloadKey: 'sha2hashb').first
-          link.expired?.should == false
+          expect(link.expired?).to eq(false)
        end
      end
      describe "expired" do
@@ -62,7 +62,7 @@ describe SingleUseLink do
 
        it "should expire link" do
           link = SingleUseLink.where(downloadKey: 'sha2hashb').first
-          link.expired?.should == true
+          expect(link.expired?).to eq(true)
        end
      end
   end

data/spec/models/solr_document_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe SolrDocument do
+describe SolrDocument, :type => :model do
 
   describe "date_uploaded" do
     before do

data/spec/models/trophy_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Trophy do
+describe Trophy, :type => :model do
    before(:all) do
     @trophy = Trophy.create(user_id:99,generic_file_id:"99")
   end
@@ -9,17 +9,17 @@ describe Trophy do
   end
 
   it "should have a user" do
-     @trophy.should respond_to(:user_id)
-     @trophy.user_id.should == 99
+     expect(@trophy).to respond_to(:user_id)
+     expect(@trophy.user_id).to eq(99)
   end
   it "should have a file" do
-     @trophy.should respond_to(:generic_file_id)
-     @trophy.generic_file_id.should == "99"
+     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)}
-     Trophy.where(user_id:120).count.should == 5
+     expect(Trophy.where(user_id:120).count).to eq(5)
      Trophy.where(user_id:120).map(&:delete)
   end
 end