sufia 4.0.0.rc1 → 4.0.0.rc2

data/spec/helpers/records_helper_spec.rb

@@ -23,6 +23,18 @@ describe RecordsHelper do
     i.attr('class').should == 'glyphicon glyphicon-question-sign large-icon'
   end
 
+  specify "draws help_icon_modal" do
+    str = String.new(helper.help_icon_modal('myModal'))
+    doc = Nokogiri::HTML(str)
+    a = doc.xpath('//a').first
+
+    expect(a.attr('href')).to eq('#myModal')
+    expect(a.attr('data-toggle')).to eq('modal')
+    expect(a.attr('id')).to eq('generic_file_myModal_help_modal')
+    i = a.children.first
+    expect(i.attr('class')).to eq('glyphicon glyphicon-question-sign large-icon')
+  end
+
   describe "download links" do
 
     before :all do

data/spec/jobs/active_fedora_pid_based_job_spec.rb

@@ -13,6 +13,6 @@ describe ActiveFedoraPidBasedJob do
   it "finds object" do
     job = ActiveFedoraPidBasedJob.new(file.id)
     expect(job.generic_file).to_not be_nil
-    expect(job.generic_file.reload_on_save?).to be_true
+    expect(job.generic_file).to be_reload_on_save
   end
 end

data/spec/jobs/audit_job_spec.rb

@@ -7,7 +7,6 @@ describe AuditJob do
     @file = GenericFile.new
     @file.apply_depositor_metadata(@user)
     @file.save
-    @ds = @file.datastreams.first
   end
   after do
     @file.delete
@@ -15,7 +14,7 @@ describe AuditJob do
   describe "passing audit" do
     it "should not send passing mail" do
       ActiveFedora::RelsExtDatastream.any_instance.stub(:dsChecksumValid).and_return(true)
-      AuditJob.new(@file.pid, @ds[0], @ds[1].versionID).run
+      AuditJob.new(@file.pid, "RELS-EXT", @file.rels_ext.versionID).run
       @inbox = @user.mailbox.inbox
       @inbox.count.should == 0
     end
@@ -23,7 +22,7 @@ describe AuditJob do
   describe "failing audit" do
     it "should send failing mail" do
       ActiveFedora::RelsExtDatastream.any_instance.stub(:dsChecksumValid).and_return(false)
-      AuditJob.new(@file.pid, @ds[0], @ds[1].versionID).run
+      AuditJob.new(@file.pid, "RELS-EXT", @file.rels_ext.versionID).run
       @inbox = @user.mailbox.inbox
       @inbox.count.should == 1
       @inbox.each { |msg| msg.last_message.subject.should == AuditJob::FAIL }

data/spec/jobs/batch_update_job_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 describe BatchUpdateJob do
+  
   before do
     @user = FactoryGirl.find_or_create(:jill)
     @batch = Batch.new
@@ -12,36 +13,50 @@ describe BatchUpdateJob do
     @file2.apply_depositor_metadata('otherUser')
     @file2.save
   end
+  
   after do
+    @user.mailbox.inbox[0].messages[0].move_to_trash @user
     @batch.delete
     @file.delete
     @file2.delete
   end
-  describe "failing update" do
-    it "should check permissions for each file before updating" do
-      User.any_instance.should_receive(:can?).with(:edit, @file).and_return(false)
-      User.any_instance.should_receive(:can?).with(:edit, @file2).and_return(false)
-       params = {'generic_file' => {'read_groups_string' => '', 'read_users_string' => 'archivist1, archivist2', 'tag' => ['']}, 'id' => @batch.pid, 'controller' => 'batch', 'action' => 'update'}.with_indifferent_access
-      BatchUpdateJob.new(@user.user_key, params).run
-      @user.mailbox.inbox[0].messages[0].subject.should == "Batch upload permission denied"
-      @user.mailbox.inbox[0].messages[0].move_to_trash @user
-      #b = Batch.find(@batch.pid)
+  
+  describe "#run" do
+    let(:params) do
+      {
+        generic_file: {
+          read_groups_string: '', read_users_string: 'archivist1, archivist2', tag: ['']
+        }, 
+        id: @batch.pid,
+        controller: 'batch',
+        action: 'update'
+      }.with_indifferent_access
     end
-  end
-  describe "passing update" do
-    it "should log a content update event" do
-      User.any_instance.should_receive(:can?).with(:edit, @file).and_return(true)
-      User.any_instance.should_receive(:can?).with(:edit, @file2).and_return(true)
-      s1 = double('one')
-      ContentUpdateEventJob.should_receive(:new).with(@file.pid, @user.user_key).and_return(s1)
-      Sufia.queue.should_receive(:push).with(s1).once
-      s2 = double('two')
-      ContentUpdateEventJob.should_receive(:new).with(@file2.pid, @user.user_key).and_return(s2)
-      Sufia.queue.should_receive(:push).with(s2).once
-      params = {'generic_file' => {'read_groups_string' => '', 'read_users_string' => 'archivist1, archivist2', 'tag' => ['']}, 'id' => @batch.pid, 'controller' => 'batch', 'action' => 'update'}.with_indifferent_access
-      BatchUpdateJob.new(@user.user_key, params).run
-      @user.mailbox.inbox[0].messages[0].subject.should == "Batch upload complete"
-      @user.mailbox.inbox[0].messages[0].move_to_trash @user
+    context "with a failing update" do
+      it "should check permissions for each file before updating" do
+        User.any_instance.should_receive(:can?).with(:edit, @file).and_return(false)
+        User.any_instance.should_receive(:can?).with(:edit, @file2).and_return(false)
+        BatchUpdateJob.new(@user.user_key, params).run
+        @user.mailbox.inbox[0].messages[0].subject.should == "Batch upload permission denied"
+        @user.mailbox.inbox[0].messages[0].body.should include("data-content")
+        @user.mailbox.inbox[0].messages[0].body.should include("These files")
+      end
+    end
+    context "with a passing update" do
+      let(:s1) { double('one') }
+      let(:s2) { double('two') }
+      it "should log a content update event" do
+        User.any_instance.should_receive(:can?).with(:edit, @file).and_return(true)
+        User.any_instance.should_receive(:can?).with(:edit, @file2).and_return(true)
+        ContentUpdateEventJob.should_receive(:new).with(@file.pid, @user.user_key).and_return(s1)
+        Sufia.queue.should_receive(:push).with(s1).once
+        ContentUpdateEventJob.should_receive(:new).with(@file2.pid, @user.user_key).and_return(s2)
+        Sufia.queue.should_receive(:push).with(s2).once
+        BatchUpdateJob.new(@user.user_key, params).run
+        @user.mailbox.inbox[0].messages[0].subject.should == "Batch upload complete"
+        @user.mailbox.inbox[0].messages[0].body.should include("data-content")
+        @user.mailbox.inbox[0].messages[0].body.should include("These files")
+      end
     end
   end
 end

data/spec/jobs/event_jobs_spec.rb

@@ -7,7 +7,7 @@ describe 'event jobs' do
     @third_user = FactoryGirl.find_or_create(:curator)
     @gf = GenericFile.new(pid: 'test:123')
     @gf.apply_depositor_metadata(@user)
-    @gf.title = 'Hamlet'
+    @gf.title = ['Hamlet']
     @gf.save
   end
   after(:each) do

data/spec/lib/sufia/id_service_spec.rb

@@ -2,15 +2,33 @@ require 'spec_helper'
 
 describe Sufia::IdService do
   describe "mint" do
-    before(:all) do
-      @id = Sufia::IdService.mint
+    subject { Sufia::IdService.mint }
+
+    it { should_not be_empty }
+
+    it "should not mint the same id twice in a row" do
+      expect(Sufia::IdService.mint).to_not eq subject
     end
-    it "should create a unique id" do
-      @id.should_not be_empty
+
+    it "should be valid" do    
+      expect(Sufia::IdService.valid?(subject)).to be true
     end
-    it "should not mint the same id twice in a row" do
-      other_id = Sufia::IdService.mint
-      other_id.should_not == @id
+
+    context "when the pid already exists in Fedora" do
+      let(:mock_pid) { 'scholarsphere:ef12ef12f' }
+      let(:unique_pid) {  'scholarsphere:bb22bb22b' }
+
+      before do
+        allow(Sufia::IdService).to receive(:next_id).and_return(mock_pid, unique_pid)
+        expect(ActiveFedora::Base).to receive(:exists?).with(mock_pid).and_return(true)
+        expect(ActiveFedora::Base).to receive(:exists?).with(unique_pid).and_return(false)
+      end
+
+      it "should not assign that pid again" do
+        expect(subject).to eq unique_pid
+      end
     end
   end
+
+
 end

data/spec/lib/sufia/messages_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Sufia::Messages do
+
+  let(:message) do
+    class TestClass
+      include Sufia::Messages
+    end
+    TestClass.new
+  end
+
+  let(:batch_id)  { "1" }
+  let(:single)    { double(noid: "1", to_s: "File 1") }
+  let(:multiple)  { [ double(noid: "1", to_s: "File 1"), double(noid: "2", to_s: "File 2"), double(noid: "3", to_s: "File 3") ] }
+  let(:file_list) { "<a href='/files/1'>File 1</a>, <a href='/files/2'>File 2</a>, <a href='/files/3'>File 3</a>"  }
+
+  describe "message subjects" do
+    it "should provide a subject for a success message" do
+      expect(message.success_subject).to eq("Batch upload complete")
+    end
+    it "should provide a subject for a failure message" do
+      expect(message.failure_subject).to eq("Batch upload permission denied")
+    end
+  end
+
+  describe "#single_success" do
+    let(:expected) { '<span id="ss-1"><a href="/files/1">File 1</a> has been saved.</span>' }
+    it "should render a success message for a single file" do
+      expect(message.single_success(batch_id, single)).to eq(expected)
+    end
+  end
+
+  describe "#multiple_success" do
+    let(:expected) { '<span id="ss-1"><a data-content="'+file_list+'" data-title="Files uploaded successfully" href="#" rel="popover">These files</a> have been saved.</span>' }
+    it "should render a success message for multiple files" do
+      expect(message.multiple_success(batch_id, multiple)).to eq(expected)
+    end
+  end
+
+  describe "#single_failure" do
+    let(:expected) { '<span id="ss-1"><a href="/files/1">File 1</a> could not be updated. You do not have sufficient privileges to edit it.</span>' }
+    it "should render a failure message for a single file" do
+      expect(message.single_failure(batch_id, single)).to eq(expected)
+    end
+  end
+
+  describe "#multiple_failure" do
+    let(:expected) { '<span id="ss-1"><a data-content="'+file_list+'" data-title="Files failed" href="#" rel="popover">These files</a> could not be updated. You do not have sufficient privileges to edit them.</span>' }
+    it "should render a failure message for multiple files" do
+      expect(message.multiple_failure(batch_id, multiple)).to eq(expected)
+    end
+  end
+
+  describe "#file_list" do
+    it "should replace double-quotes with single quotes" do
+      expect(message.file_list(multiple)).to eq(file_list)
+    end
+  end
+
+end

data/spec/lib/sufia/readable_permissions_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Sufia::Permissions::Readable do
+
+  class SubjectClass
+    include Sufia::Permissions::Readable
+    attr_accessor :read_groups 
+  end
+  let(:subject) { SubjectClass.new }
+
+  describe "#public?" do
+    it "should return true for public items" do
+      subject.read_groups = ["public","othergroup"]
+      expect(subject).to be_public
+    end
+    it "should return fale for non-public items" do
+      subject.read_groups = ["notpublic","othergroup"]
+      expect(subject).to_not be_public
+    end
+  end
+
+  describe "#registered?" do
+    it "should return true for registered items" do
+      subject.read_groups = ["registered","othergroup"]
+      expect(subject).to be_registered
+    end
+    it "should return fale for non-registered items" do
+      subject.read_groups = ["othergroup"]
+      expect(subject).to_not be_registered
+    end
+  end
+
+  describe "#private?" do
+    context "is true" do
+      specify "when there are no groups defined" do
+        subject.read_groups = []
+        expect(subject).to be_private
+      end
+      specify "when groups do not include 'public' or 'registered'" do
+        subject.read_groups = ["othergroup"]
+        expect(subject).to be_private
+      end
+    end
+    context "is false" do
+      specify "when 'registered' group is present" do
+        subject.read_groups = ["registered"]
+        expect(subject).to_not be_private
+      end
+      specify "when 'public' group is present" do
+        subject.read_groups = ["public"]
+        expect(subject).to_not be_private
+      end
+    end
+  end
+
+end

data/spec/lib/sufia/writable_permissions_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Sufia::Permissions::Writable do
+
+  class SampleModel < ActiveFedora::Base
+    include Sufia::Permissions::Writable
+  end
+  let(:subject) { SampleModel.new }
+
+  it "should initialized with a parnoid rightsMetadata datastream" do
+    expect(subject.rightsMetadata).to be_kind_of ParanoidRightsDatastream
+  end
+
+  describe "#permissions" do
+    it "should initialize with nothing specified" do
+      expect(subject.permissions).to be_empty
+    end
+  end
+
+end

data/spec/models/batch_spec.rb

@@ -6,7 +6,7 @@ describe Batch do
     @file = GenericFile.new
     @file.apply_depositor_metadata('mjg36')
     @file.save
-    @batch = Batch.create(title: "test collection",
+    @batch = Batch.create(title: ["test collection"],
                           creator: @user.user_key,
                           part: @file.pid)
   end

data/spec/models/collection_spec.rb

@@ -1,15 +1,16 @@
 require 'spec_helper'
 
 describe Collection do
-  before(:all) do
+  before do
     @user = FactoryGirl.create(:user)
     @collection = Collection.new(title: "test collection").tap do |c|
       c.apply_depositor_metadata(@user.user_key)
     end
   end
 
-  after(:all) do
+  after do
     @collection.delete
+    @user.destroy
   end
 
   it "should have open visibility" do
@@ -21,4 +22,25 @@ describe Collection do
      @collection.title = nil
      expect{ @collection.save! }.to raise_error(ActiveFedora::RecordInvalid)
   end
+
+  describe "::bytes" do
+
+    context "with no items" do
+      specify "is zero" do
+        @collection.save
+        expect(@collection.bytes).to eq 0
+      end
+    end
+
+    context "with characterized GenericFiles" do
+      let(:file) { mock_model GenericFile, file_size: ["50"] }
+      before do
+        allow(@collection).to receive(:members).and_return([file, file])
+      end
+      specify "is the sum of the files' sizes" do
+        expect(@collection.bytes).to eq 100
+      end
+    end
+
+  end
 end

data/spec/models/featured_work_spec.rb

@@ -21,7 +21,7 @@ describe FeaturedWork do
   describe "can_create_another?" do
     subject { FeaturedWork }
     context "when none exist" do
-      its(:can_create_another?) { should be_true }
+      its(:can_create_another?) { should be true }
     end
     context "when five exist" do
       before do
@@ -29,7 +29,7 @@ describe FeaturedWork do
           FeaturedWork.create(generic_file_id:n.to_s)
         end
       end
-      its(:can_create_another?) { should be_false }
+      its(:can_create_another?) { should be false }
     end
   end
 

data/spec/models/file_content_datastream_spec.rb

@@ -78,17 +78,17 @@ describe FileContentDatastream do
     end
     it "should only return true when the datastream has actually changed" do
       @generic_file.add_file(File.open(fixture_path + '/world.png', 'rb'), 'content', 'world.png')
-      @generic_file.content.changed?.should be_true
+      expect(@generic_file.content).to be_changed
       @generic_file.save!
-      @generic_file.content.changed?.should be_false
+      expect(@generic_file.content).to_not be_changed
 
       # Add a thumbnail ds
       @generic_file.add_file(File.open(fixture_path + '/world.png'), 'thumbnail', 'world.png')
-      @generic_file.thumbnail.changed?.should be_true
-      @generic_file.content.changed?.should be_false
+      expect(@generic_file.thumbnail).to be_changed
+      expect(@generic_file.content).to_not be_changed
 
       retrieved_file = @generic_file.reload
-      retrieved_file.content.changed?.should be_false
+      expect(retrieved_file.content).to_not be_changed
     end
   end
 end

data/spec/models/generic_file_spec.rb

@@ -27,6 +27,13 @@ describe GenericFile do
     end
   end
 
+  describe "assign_pid" do
+    it "should use the noid id service" do
+      expect_any_instance_of(Rubydora::Fc3Service).to_not receive(:next_pid)
+      GenericFile.assign_pid(nil)
+    end
+  end
+
   describe "mime type recognition" do
     context "when image?" do
       it "should be true for jpeg2000" do
@@ -243,9 +250,9 @@ describe GenericFile do
         f.should respond_to(:log_event)
       end
       it "should be able to set values via delegated methods" do
-        subject.related_url = "http://example.org/"
-        subject.creator = "John Doe"
-        subject.title = "New work"
+        subject.related_url = ["http://example.org/"]
+        subject.creator = ["John Doe"]
+        subject.title = ["New work"]
         subject.save
         f = subject.reload
         f.related_url.should == ["http://example.org/"]
@@ -253,13 +260,13 @@ describe GenericFile do
         f.title.should == ["New work"]
       end
       it "should be able to be added to w/o unexpected graph behavior" do
-        subject.creator = "John Doe"
-        subject.title = "New work"
+        subject.creator = ["John Doe"]
+        subject.title = ["New work"]
         subject.save
         f = subject.reload
         f.creator.should == ["John Doe"]
         f.title.should == ["New work"]
-        f.creator = "Jane Doe"
+        f.creator = ["Jane Doe"]
         f.title << "Newer work"
         f.save
         f = subject.reload
@@ -271,24 +278,25 @@ describe GenericFile do
   describe "to_solr" do
     before do
       allow(subject).to receive(:pid).and_return('stubbed_pid')
-      subject.part_of = "Arabiana"
-      subject.contributor = "Mohammad"
-      subject.creator = "Allah"
-      subject.title = "The Work"
-      subject.description = "The work by Allah"
-      subject.publisher = "Vertigo Comics"
-      subject.date_created = "1200-01-01"
+      subject.part_of = ["Arabiana"]
+      subject.contributor = ["Mohammad"]
+      subject.creator = ["Allah"]
+      subject.title = ["The Work"]
+      subject.description = ["The work by Allah"]
+      subject.publisher = ["Vertigo Comics"]
+      subject.date_created = ["1200-01-01"]
       subject.date_uploaded = Date.parse("2011-01-01")
       subject.date_modified = Date.parse("2012-01-01")
-      subject.subject = "Theology"
-      subject.language = "Arabic"
-      subject.rights = "Wide open, buddy."
-      subject.resource_type = "Book"
-      subject.identifier = "urn:isbn:1234567890"
-      subject.based_near = "Medina, Saudi Arabia"
-      subject.related_url = "http://example.org/TheWork/"
+      subject.subject = ["Theology"]
+      subject.language = ["Arabic"]
+      subject.rights = ["Wide open, buddy."]
+      subject.resource_type = ["Book"]
+      subject.identifier = ["urn:isbn:1234567890"]
+      subject.based_near = ["Medina, Saudi Arabia"]
+      subject.related_url = ["http://example.org/TheWork/"]
       subject.mime_type = "image/jpeg"
-      subject.format_label = "JPEG Image"
+      subject.format_label = ["JPEG Image"]
+      subject.full_text.content = 'abcxyz'
     end
     it "supports to_solr" do
       local = subject.to_solr
@@ -314,6 +322,7 @@ describe GenericFile do
       expect(local[Solrizer.solr_name("desc_metadata__based_near")]).to eq ["Medina, Saudi Arabia"]
       expect(local[Solrizer.solr_name("mime_type")]).to eq ["image/jpeg"]
       expect(local["noid_tsi"]).to eq 'stubbed_pid'
+      expect(local['all_text_timv']).to eq('abcxyz')
     end
   end
   it "should support multi-valued fields in solr" do
@@ -348,26 +357,25 @@ describe GenericFile do
   end
   describe "trophies" do
     before do
-      u = FactoryGirl.create(:jill)
+      u = FactoryGirl.find_or_create(:jill)
       @f = GenericFile.new.tap do |gf|
         gf.apply_depositor_metadata(u)
         gf.save!
       end
-      @t = Trophy.create(user_id: u.id, generic_file_id: @f.pid)
+      @t = Trophy.create(user_id: u.id, generic_file_id: @f.noid)
     end
     it "should have a trophy" do
-      Trophy.where(generic_file_id: @f.pid).count.should == 1
+      expect(Trophy.where(generic_file_id: @f.noid).count).to eq 1
     end
     it "should remove all trophies when file is deleted" do
-      @f.should_receive(:cleanup_trophies)
       @f.destroy
-      Trophy.where(generic_file_id: @f.pid).count.should == 0
+      expect(Trophy.where(generic_file_id: @f.noid).count).to eq 0
     end
   end
 
   describe "audit" do
     before do
-      u = FactoryGirl.create(:jill)
+      u = FactoryGirl.find_or_create(:jill)
       f = GenericFile.new
       f.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
       f.apply_depositor_metadata(u)
@@ -399,16 +407,16 @@ describe GenericFile do
       @f.datastreams.each { |ds| ds.stub(:dsChecksumValid).and_return(false) }
       GenericFile.stub(:run_audit).and_return(double(:respose, pass:1, created_at: '2005-12-20', pid: 'foo:123', dsid: 'foo', version: '1'))
       @f.audit!
-      ChecksumAuditLog.all.all? { |cal| cal.pass == 0 }.should be_true
+      expect(ChecksumAuditLog.all).to be_all { |cal| cal.pass == 0 }
     end
     it "should log a passing audit" do
       GenericFile.stub(:run_audit).and_return(double(:respose, pass:1, created_at: '2005-12-20', pid: 'foo:123', dsid: 'foo', version: '1'))
       @f.audit!
-      ChecksumAuditLog.all.all? { |cal| cal.pass == 1 }.should be_true
+      expect(ChecksumAuditLog.all).to be_all { |cal| cal.pass == 1 }
     end
 
     it "should return true on audit_status" do
-      @f.audit_stat.should be_true
+      expect(@f.audit_stat).to be_truthy
     end
   end
 
@@ -443,39 +451,46 @@ describe GenericFile do
 
   end
 
-  describe "related_files" do
-    let(:batch_id) { "foobar:100" }
-    before(:each) do
-      @f1 = GenericFile.new
-      @f2 = GenericFile.new
-      @f3 = GenericFile.new
-      @f1.apply_depositor_metadata('mjg36')
-      @f2.apply_depositor_metadata('mjg36')
-      @f3.apply_depositor_metadata('mjg36')
+  describe "#related_files" do
+    let!(:f1) do
+      GenericFile.new.tap do |f|
+        f.apply_depositor_metadata('mjg36')
+        f.batch_id = batch_id
+        f.save
+      end
     end
-
-    describe "when the files belong to a batch" do
-      after(:each) do
-        @f1.delete
-        @f2.delete
-        @f3.delete
+    let!(:f2) do
+      GenericFile.new.tap do |f|
+        f.apply_depositor_metadata('mjg36')
+        f.batch_id = batch_id
+        f.save
       end
-      before do
-        @f1.add_relationship("isPartOf", "info:fedora/#{@batch_id}")
-        @f2.add_relationship("isPartOf", "info:fedora/#{@batch_id}")
-        @f3.add_relationship("isPartOf", "info:fedora/#{@batch_id}")
-        @f1.save!
-        @f2.save!
-        @f3.save!
+    end
+    let!(:f3) do
+      GenericFile.new.tap do |f|
+        f.apply_depositor_metadata('mjg36')
+        f.batch_id = batch_id
+        f.save
       end
-      it "should never return a file in its own related_files method" do
-        @f1.related_files.should match_array [@f2, @f3]
-        @f2.related_files.should match_array [@f1, @f3]
-        @f3.related_files.should match_array [@f1, @f2]
+    end
+
+    context "when the files belong to a batch" do
+      let(:batch) { Batch.create }
+      let(:batch_id) { batch.id }
+
+      it "shouldn't return itself from the related_files method" do
+        expect(f1.related_files).to match_array [f2, f3]
+        expect(f2.related_files).to match_array [f1, f3]
+        expect(f3.related_files).to match_array [f1, f2]
       end
     end
-    it "should return an empty array when there are no related files" do
-      @f1.related_files.should == []
+
+    context "when there are no related files" do
+      let(:batch_id) { nil }
+
+      it "should return an empty array when there are no related files" do
+        expect(f1.related_files).to eq []
+      end
     end
   end
   describe "noid integration" do
@@ -512,12 +527,12 @@ describe GenericFile do
         myfile.add_file(File.open(fixture_path + '/sufia/sufia_test4.pdf', 'rb').read, 'content', 'sufia_test4.pdf')
         myfile.label = 'label123'
         myfile.apply_depositor_metadata('mjg36')
+        # characterize method saves
         myfile.characterize
-        myfile.save
         @myfile = myfile.reload
       end
       after(:all) do
-        @myfile.delete
+        @myfile.destroy
       end
       it "should return expected results after a save" do
         @myfile.file_size.should == ['218882']
@@ -535,12 +550,14 @@ describe GenericFile do
         @myfile.title.should include("Microsoft Word - sample.pdf.docx")
         @myfile.filename[0].should == @myfile.label
       end
-
       it "should append each term only once" do
         @myfile.append_metadata
         @myfile.format_label.should == ["Portable Document Format"]
         @myfile.title.should include("Microsoft Word - sample.pdf.docx")
       end
+      it 'includes extracted full-text content' do
+        expect(@myfile.full_text.content).to eq("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nMicrosoft Word - sample.pdf.docx\n\n\n \n \n\n \n\n \n\n \n\nThis PDF file was created using CutePDF. \n\nwww.cutepdf.com")
+      end
     end
   end
   describe "label" do
@@ -618,66 +635,66 @@ describe GenericFile do
       it "should work via permissions=()" do
         @file.permissions = {user: {'mjg36' => 'read'}}
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_users)
         @file.errors[:edit_users].should include('Depositor must have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via update_attributes" do
         # automatically triggers save
         lambda { @file.update_attributes(read_users_string: 'mjg36') }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_users)
         @file.errors[:edit_users].should include('Depositor must have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via update_indexed_attributes" do
         @rightsmd.update_indexed_attributes([:edit_access, :person] => '')
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_users)
         @file.errors[:edit_users].should include('Depositor must have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via permissions()" do
         @rightsmd.permissions({person: "mjg36"}, "read")
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_users)
         @file.errors[:edit_users].should include('Depositor must have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via update_permissions()" do
         @rightsmd.update_permissions({"person" => {"mjg36" => "read"}})
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_users)
         @file.errors[:edit_users].should include('Depositor must have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via content=()" do
         @rightsmd.content=(@rights_xml)
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_users)
         @file.errors[:edit_users].should include('Depositor must have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via ng_xml=()" do
         @rightsmd.ng_xml=(Nokogiri::XML::Document.parse(@rights_xml))
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_users)
         @file.errors[:edit_users].should include('Depositor must have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via update_values()" do
         @rightsmd.update_values([:edit_access, :person] => '')
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_users)
         @file.errors[:edit_users].should include('Depositor must have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
     end
     context "public must not have edit access" do
@@ -718,66 +735,66 @@ describe GenericFile do
       it "should work via permissions=()" do
         @file.permissions = {group: {'public' => 'edit'}}
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Public cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via update_attributes" do
         # automatically triggers save
         lambda { @file.update_attributes(edit_groups_string: 'public') }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Public cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via update_indexed_attributes" do
         @rightsmd.update_indexed_attributes([:edit_access, :group] => 'public')
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Public cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via permissions()" do
         @rightsmd.permissions({group: "public"}, "edit")
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Public cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via update_permissions()" do
         @rightsmd.update_permissions({"group" => {"public" => "edit"}})
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Public cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via content=()" do
         @rightsmd.content=(@rights_xml)
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Public cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via ng_xml=()" do
         @rightsmd.ng_xml=(Nokogiri::XML::Document.parse(@rights_xml))
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Public cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via update_values()" do
         @rightsmd.update_values([:edit_access, :group] => 'public')
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Public cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
     end
     context "registered must not have edit access" do
@@ -818,66 +835,66 @@ describe GenericFile do
       it "should work via permissions=()" do
         @file.permissions = {group: {'registered' => 'edit'}}
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Registered cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via update_attributes" do
         # automatically triggers save
         lambda { @file.update_attributes(edit_groups_string: 'registered') }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Registered cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via update_indexed_attributes" do
         @rightsmd.update_indexed_attributes([:edit_access, :group] => 'registered')
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Registered cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via permissions()" do
         @rightsmd.permissions({group: "registered"}, "edit")
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Registered cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via update_permissions()" do
         @rightsmd.update_permissions({"group" => {"registered" => "edit"}})
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Registered cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via content=()" do
         @rightsmd.content=(@rights_xml)
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Registered cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via ng_xml=()" do
         @rightsmd.ng_xml=(Nokogiri::XML::Document.parse(@rights_xml))
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Registered cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
       it "should work via update_values()" do
         @rightsmd.update_values([:edit_access, :group] => 'registered')
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_true
+        expect(@file).to be_new_record
         @file.errors.should include(:edit_groups)
         @file.errors[:edit_groups].should include('Registered cannot have edit access')
-        @file.valid?.should be_false
+        expect(@file).to_not be_valid
       end
     end
     context "everything is copacetic" do
@@ -920,58 +937,58 @@ describe GenericFile do
       it "should work via permissions=()" do
         @file.permissions = {group: {'registered' => 'read'}}
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_false
+        expect(@file).to_not be_new_record
         @file.errors.should be_empty
-        @file.valid?.should be_true
+        expect(@file).to be_valid
       end
       it "should work via update_attributes" do
         # automatically triggers save
         lambda { @file.update_attributes(read_groups_string: 'registered') }.should_not raise_error
-        @file.new_record?.should be_false
+        expect(@file).to_not be_new_record
         @file.errors.should be_empty
-        @file.valid?.should be_true
+        expect(@file).to be_valid
       end
       it "should work via update_indexed_attributes" do
         @rightsmd.update_indexed_attributes([:read_access, :group] => 'registered')
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_false
+        expect(@file).to_not be_new_record
         @file.errors.should be_empty
-        @file.valid?.should be_true
+        expect(@file).to be_valid
       end
       it "should work via permissions()" do
         @rightsmd.permissions({group: "registered"}, "read")
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_false
+        expect(@file).to_not be_new_record
         @file.errors.should be_empty
-        @file.valid?.should be_true
+        expect(@file).to be_valid
       end
       it "should work via update_permissions()" do
         @rightsmd.update_permissions({"group" => {"registered" => "read"}})
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_false
+        expect(@file).to_not be_new_record
         @file.errors.should be_empty
-        @file.valid?.should be_true
+        expect(@file).to be_valid
       end
       it "should work via content=()" do
         @rightsmd.content=(@rights_xml)
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_false
+        expect(@file).to_not be_new_record
         @file.errors.should be_empty
-        @file.valid?.should be_true
+        expect(@file).to be_valid
       end
       it "should work via ng_xml=()" do
         @rightsmd.ng_xml=(Nokogiri::XML::Document.parse(@rights_xml))
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_false
+        expect(@file).to_not be_new_record
         @file.errors.should be_empty
-        @file.valid?.should be_true
+        expect(@file).to be_valid
       end
       it "should work via update_values()" do
         @rightsmd.update_values([:read_access, :group] => 'registered')
         lambda { @file.save }.should_not raise_error
-        @file.new_record?.should be_false
+        expect(@file).to_not be_new_record
         @file.errors.should be_empty
-        @file.valid?.should be_true
+        expect(@file).to be_valid
       end
     end
   end
@@ -1011,7 +1028,7 @@ describe GenericFile do
      f2 = GenericFile.find(subject.id)
      f2.reload_on_save = true
      f1.mime_type = "video/abc123"
-     f2.title = "abc123"
+     f2.title = ["abc123"]
      f1.save
      mime_type_key = Solrizer.solr_name("mime_type")
      title_key = Solrizer.solr_name("desc_metadata__title", :stored_searchable, type: :string)
@@ -1024,15 +1041,14 @@ describe GenericFile do
   end
 
   describe "public?" do
-    it "is true when read group is set to public" do
-      subject.read_groups = ['public']
-      expect(subject.public?).to be_true
+    context "when read group is set to public" do
+      before { subject.read_groups = ['public'] }
+      it { should be_public }
     end
 
-    it "is false when read group is not set to public" do
-      subject.read_groups = ['foo']
-      expect(subject.public?).to be_false
+    context "when read group is not set to public" do
+      before { subject.read_groups = ['foo'] }
+      it { should_not be_public }
     end
-
   end
 end