sufia 5.0.0 → 6.0.0.beta1

data/spec/models/characterization_spec.rb

@@ -5,7 +5,7 @@ describe Sufia::GenericFile::Characterization, :type => :model do
     class TestClass < ActiveFedora::Base
       include Sufia::GenericFile::Characterization
 
-      has_file_datastream 'content', type: FileContentDatastream
+      contains 'content', class_name: 'FileContentDatastream'
       attr_accessor :title, :creator
     end
   end

data/spec/models/checksum_audit_log_spec.rb

@@ -1,43 +1,65 @@
 require 'spec_helper'
 
-describe ChecksumAuditLog, :type => :model do
+describe ChecksumAuditLog do
+  before do
+    allow_any_instance_of(GenericFile).to receive(:characterize).and_return(true) # stub out characterization so it does not get audited
+  end
+
   let(:f) do
-    GenericFile.new.tap do |gf|
+    GenericFile.create do |gf|
       gf.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
       gf.apply_depositor_metadata('mjg36')
-      gf.save!
     end
   end
-  let(:version) { f.datastreams['content'].versions.first }
-  let(:old) do
-    ChecksumAuditLog.create(pid: f.pid, dsid: version.dsid, version: version.versionID, pass: 1, created_at: 2.minutes.ago)
-  end
-  let(:new) do
-    ChecksumAuditLog.create(pid: f.pid, dsid: version.dsid, version: version.versionID, pass: 0, created_at: 1.minute.ago)
-  end
-  after(:all) do
-    ChecksumAuditLog.destroy_all
-  end
-  before do
-    allow_any_instance_of(GenericFile).to receive(:characterize).and_return(true) # stub out characterization so it does not get audited
+
+  let(:version_uri) { f.content.versions.first.uri }
+  let(:version_path) { 'content' }
+  let(:old) { ChecksumAuditLog.create(pid: f.id, dsid: version_path, version: version_uri, pass: 1, created_at: 2.minutes.ago) }
+  let(:new) { ChecksumAuditLog.create(pid: f.id, dsid: version_path, version: version_uri, pass: 0, created_at: 1.minute.ago) }
+
+  context "a file with multiple checksums audits" do
+    specify "should return a list of logs for this datastream sorted by date descending" do
+      logs = ChecksumAuditLog.logs_for(f.id, version_path)
+      expect(logs).to eq([new, old])
+    end
   end
-  it "returns a list of logs for this datastream sorted by date descending" do
-    expect(f.logs(version.dsid)).to eq [new, old]
+
+  context "after multiple checksum audits where the checksum does not change" do
+    specify "only one of them should be kept" do
+      success1 = ChecksumAuditLog.create(pid: f.id, dsid: version_path, version: version_uri, pass: 1)
+      ChecksumAuditLog.prune_history(f.id, version_path)
+      success2 = ChecksumAuditLog.create(pid: f.id, dsid: version_path, version: version_uri, pass: 1)
+      ChecksumAuditLog.prune_history(f.id, version_path)
+      success3 = ChecksumAuditLog.create(pid: f.id, dsid: version_path, version: version_uri, pass: 1)
+      ChecksumAuditLog.prune_history(f.id, version_path)
+
+      expect { ChecksumAuditLog.find(success2.id) }.to raise_exception ActiveRecord::RecordNotFound
+      expect { ChecksumAuditLog.find(success3.id) }.to raise_exception ActiveRecord::RecordNotFound
+      expect(ChecksumAuditLog.find(success1.id)).not_to be_nil
+      logs = ChecksumAuditLog.logs_for(f.id, version_path)
+      expect(logs).to eq([success1, new, old])
+    end
   end
-  describe "history pruning" do
+
+  context "should have an audit log history" do
     before do
-      @success1 = ChecksumAuditLog.create(pid: f.pid, dsid: version.dsid, version: version.versionID, pass: 1)
-      ChecksumAuditLog.prune_history(version)
-      @success2 = ChecksumAuditLog.create(pid: f.pid, dsid: version.dsid, version: version.versionID, pass: 1)
-      ChecksumAuditLog.prune_history(version)
-      @success3 = ChecksumAuditLog.create(pid: f.pid, dsid: version.dsid, version: version.versionID, pass: 1)
-      ChecksumAuditLog.prune_history(version)
+      ChecksumAuditLog.create(pid: f.id, dsid: 'content', version: 'v2', pass: 1)
+      ChecksumAuditLog.create(pid: f.id, dsid: 'thumbnail', version: 'v1', pass: 1)
     end
-    it "prunes history for a datastream" do
-      expect { ChecksumAuditLog.find(@success2.id)}.to raise_exception ActiveRecord::RecordNotFound
-      expect { ChecksumAuditLog.find(@success3.id)}.to raise_exception ActiveRecord::RecordNotFound
-      expect(ChecksumAuditLog.find(@success1.id)).not_to be_nil
-      expect(f.logs(version.dsid)).to eq [@success1, new, old]
+
+    specify "should have an audit log history" do
+      audit = ChecksumAuditLog.get_audit_log(f.id, 'content', version_uri)
+      expect(audit.pid).to eq(f.id)
+      expect(audit.version).to eq(version_uri)
+
+      audit = ChecksumAuditLog.get_audit_log(f.id, 'content', 'v2')
+      expect(audit.pid).to eq(f.id)
+      expect(audit.version).to eq('v2')
+
+      audit = ChecksumAuditLog.get_audit_log(f.id, 'thumbnail', 'v1')
+      expect(audit.pid).to eq(f.id)
+      expect(audit.version).to eq('v1')
+
     end
   end
 end

data/spec/models/collection_spec.rb

@@ -8,11 +8,6 @@ describe Collection, :type => :model do
     end
   end
 
-  after do
-    @collection.delete
-    @user.destroy
-  end
-
   it "should have open visibility" do
     @collection.save
     expect(@collection.read_groups).to eq ['public']

data/spec/models/featured_work_list_spec.rb

@@ -9,15 +9,13 @@ describe FeaturedWorkList, :type => :model do
     FeaturedWork.create(generic_file_id: file2.noid)
   end
 
-  after { GenericFile.destroy_all }
-
   describe 'featured_works' do
     it 'should be a list of the featured work objects, each with the generic_file\'s solr_doc' do
       expect(subject.featured_works.size).to eq 2
       solr_doc = subject.featured_works.first.generic_file_solr_document
       expect(solr_doc).to be_kind_of SolrDocument
-      expect(solr_doc.noid).to eq file1.noid 
-    end 
+      expect(solr_doc.noid).to eq file1.noid
+    end
   end
 
   describe 'file deleted' do

data/spec/models/file_content_datastream_spec.rb

@@ -1,81 +1,48 @@
 require 'spec_helper'
 
 describe FileContentDatastream, :type => :model do
-  describe "version control" do
-    before do
-      f = GenericFile.new
-      f.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
-      f.apply_depositor_metadata('mjg36')
-      f.save
-      @file = f.reload
-    end
-    after do
-      @file.delete
-    end
-    it "should have a list of versions with one entry" do
-      @file.content.versions.count == 1
-    end
-    it "should return the expected version ID" do
-      expect(@file.content.versions.first.versionID).to eq("content.0")
-    end
-    it "should support latest_version" do
-      expect(@file.content.latest_version.versionID).to eq("content.0")
-    end
-    it "should return the same version via get_version" do
-      expect(@file.content.get_version("content.0").versionID).to eq(@file.content.latest_version.versionID)
+  describe "#latest_version" do
+    let(:file) do
+      GenericFile.create do |f|
+        f.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
+        f.apply_depositor_metadata('mjg36')
+      end
     end
-    it "should not barf when a garbage ID is provided to get_version"  do
-      expect(@file.content.get_version("foobar")).to be_nil
+
+    context "with one version" do
+      subject { file.content.latest_version.label }
+      it { is_expected.to eq "version1" }
     end
-    describe "add a version" do
+
+    context "with two versions" do
       before do
-        @file.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
-        @file.save
-      end
-      it "should return two versions" do
-        @file.content.versions.count == 2
-      end
-      it "should return the newer version via latest_version" do
-        expect(@file.content.versions.first.versionID).to eq("content.1")
-      end
-      it "should return the same version via get_version" do
-        expect(@file.content.get_version("content.1").versionID).to eq(@file.content.latest_version.versionID)
+        file.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
+        file.save
       end
+      subject { file.content.latest_version.label }
+      it { is_expected.to eq "version2" }
     end
   end
+
   describe "extract_metadata" do
-    before do
-      @subject = FileContentDatastream.new(nil, 'content')
-      allow(@subject).to receive_messages(pid: 'my_pid')
-      allow(@subject).to receive_messages(dsVersionID: 'content.7')
-    end
+    let(:datastream) { FileContentDatastream.new('foo/content') }
+    let(:file) { ActionDispatch::Http::UploadedFile.new(tempfile: File.new(fixture_path + '/world.png'),
+                                                 filename: 'world.png') }
+    before { datastream.content = file }
+    let(:document) { Nokogiri::XML.parse(datastream.extract_metadata).root }
+    let(:namespace) { { 'ns'=>'http://hul.harvard.edu/ois/xml/ns/fits/fits_output' } }
+
     it "should return an xml document", unless: $in_travis do
-      f = File.new(fixture_path + '/world.png', 'rb')
-      @subject.content = f.read
-      xml = @subject.extract_metadata
-      doc = Nokogiri::XML.parse(xml)
-      expect(doc.root.xpath('//ns:imageWidth/text()', {'ns'=>'http://hul.harvard.edu/ois/xml/ns/fits/fits_output'}).inner_text).to eq('50')
-    end
-    it "should return expected results when invoked via HTTP", unless: $in_travis do
-      f = ActionDispatch::Http::UploadedFile.new(tempfile: File.new(fixture_path + '/world.png'),
-                                                 filename: 'world.png')
-      content = double("file")
-      allow(content).to receive_messages(read: f.read)
-      allow(content).to receive_messages(rewind: f.rewind)
-      allow(@subject).to receive(:content).and_return(f)
-      xml = @subject.extract_metadata
-      doc = Nokogiri::XML.parse(xml)
-      expect(doc.root.xpath('//ns:identity/@mimetype', {'ns'=>'http://hul.harvard.edu/ois/xml/ns/fits/fits_output'}).first.value).to eq('image/png')
+      expect(document.xpath('//ns:identity/@mimetype', namespace).first.value).to eq 'image/png'
     end
   end
+
   describe "changed?" do
     before do
       @generic_file = GenericFile.new
       @generic_file.apply_depositor_metadata('mjg36')
     end
-    after do
-      @generic_file.delete
-    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')
       expect(@generic_file.content).to be_changed

data/spec/models/file_usage_spec.rb

@@ -2,14 +2,11 @@ require 'spec_helper'
 
 describe FileUsage, :type => :model do
 
-  before :all do
-    @file = GenericFile.new
-    @file.apply_depositor_metadata("awead")
-    @file.save
-  end
-
-  after :all do
-    @file.delete
+  let(:file) do
+    GenericFile.new.tap do |file|
+      file.apply_depositor_metadata("awead")
+      file.save
+    end
   end
 
   let(:dates) {
@@ -33,7 +30,7 @@ describe FileUsage, :type => :model do
 
   # This is what the data looks like that's returned from Google Analytics (GA) via the Legato gem
   # Due to the nature of querying GA, testing this data in an automated fashion is problematc.
-  # Sample data structures were created by sending real events to GA from a test instance of 
+  # Sample data structures were created by sending real events to GA from a test instance of
   # Scholarsphere.  The data below are essentially a "cut and paste" from the output of query
   # results from the Legato gem.
 
@@ -61,21 +58,21 @@ describe FileUsage, :type => :model do
     allow_any_instance_of(GenericFile).to receive(:create_date).and_return((Date.today-4.day).to_s)
     expect(FileDownloadStat).to receive(:ga_statistics).and_return(sample_download_statistics)
     expect(FileViewStat).to receive(:ga_statistics).and_return(sample_pageview_statistics)
-    FileUsage.new(@file.id)
+    FileUsage.new(file.id)
   }
 
   describe "#initialize" do
 
     it "should set the id" do
-      expect(usage.id).to eq(@file.pid)
+      expect(usage.id).to eq(file.id)
     end
 
     it "should set the path" do
-      expect(usage.path).to eq("/files/#{Sufia::Noid.noidify(@file.id)}")
+      expect(usage.path).to eq("/files/#{URI.encode(Sufia::Noid.noidify(file.id), '/')}")
     end
 
     it "should set the created date" do
-      expect(usage.created).to eq(DateTime.parse(@file.create_date))
+      expect(usage.created).to eq(file.create_date)
     end
 
   end
@@ -106,12 +103,10 @@ describe FileUsage, :type => :model do
       expect(usage.to_flot[1][:data]).to include(*download_output)
     end
 
-    let(:create_date) {DateTime.new(2014, 01, 01)}
+    let(:create_date) { DateTime.new(2014, 01, 01).iso8601 }
 
     describe "analytics start date set" do
-      let(:earliest) {
-        DateTime.new(2014, 01, 02)
-      }
+      let(:earliest) { DateTime.new(2014, 01, 02).iso8601 }
 
       before do
         Sufia.config.analytic_start_date = earliest
@@ -122,7 +117,7 @@ describe FileUsage, :type => :model do
           allow_any_instance_of(GenericFile).to receive(:create_date).and_return(create_date.to_s)
           expect(FileDownloadStat).to receive(:ga_statistics).and_return(sample_download_statistics)
           expect(FileViewStat).to receive(:ga_statistics).and_return(sample_pageview_statistics)
-          FileUsage.new(@file.id)
+          FileUsage.new(file.id)
         }
         it "should set the created date to the earliest date not the created date" do
           expect(usage.created).to eq(earliest)
@@ -136,10 +131,10 @@ describe FileUsage, :type => :model do
           expect(FileDownloadStat).to receive(:ga_statistics).and_return(sample_download_statistics)
           expect(FileViewStat).to receive(:ga_statistics).and_return(sample_pageview_statistics)
           Sufia.config.analytic_start_date = earliest
-          FileUsage.new(@file.id)
+          FileUsage.new(file.id)
         }
         it "should set the created date to the earliest date not the created date" do
-          expect(usage.created).to eq(@file.create_date)
+          expect(usage.created).to eq(file.create_date)
         end
       end
     end
@@ -152,7 +147,7 @@ describe FileUsage, :type => :model do
         allow_any_instance_of(GenericFile).to receive(:create_date).and_return(create_date.to_s)
         expect(FileDownloadStat).to receive(:ga_statistics).and_return(sample_download_statistics)
         expect(FileViewStat).to receive(:ga_statistics).and_return(sample_pageview_statistics)
-        FileUsage.new(@file.id)
+        FileUsage.new(file.id)
       }
       it "should set the created date to the earliest date not the created date" do
         expect(usage.created).to eq(create_date)

data/spec/models/fits_datastream_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe FitsDatastream, type: :model, unless: $in_travis do
   describe "image" do
     before(:all) do
-      @file = GenericFile.new
+      @file = GenericFile.new(id: 'foo123')
       @file.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
       @file.characterize
     end
@@ -31,10 +31,24 @@ describe FitsDatastream, type: :model, unless: $in_travis do
     it "should have a width" do
       expect(@file.width).to eq ["50"]
     end
+
+    let(:datastream) { @file.characterization }
+    let(:xml) { datastream.ng_xml }
+    let(:namespace) { {'ns'=>'http://hul.harvard.edu/ois/xml/ns/fits/fits_output'} }
+    let(:solr_doc) { @file.to_solr }
+
+    it "should make the fits XML" do
+      expect(xml.xpath('//ns:imageWidth/text()', namespace).inner_text).to eq '50'
+    end
+
+    it "should index into solr" do
+      expect(solr_doc[Solrizer.solr_name("mime_type")].first).to eq "image/png"
+    end 
   end
+
   describe "video" do
     before(:all) do
-      @file = GenericFile.new
+      @file = GenericFile.new(id: 'foo123')
       @file.add_file(File.open(fixture_path + '/sample_mpeg4.mp4'), 'content', 'sample_mpeg4.mp4')
       @file.characterize
     end
@@ -73,4 +87,35 @@ describe FitsDatastream, type: :model, unless: $in_travis do
       expect(@file.frame_rate[0].to_f).to eq 30.0
     end
   end
+
+  describe "pdf" do
+    before do
+      @myfile = GenericFile.new(id: 'foo123')
+      @myfile.add_file(File.open(fixture_path + '/sufia/sufia_test4.pdf', 'rb').read, 'content', 'sufia_test4.pdf')
+      @myfile.apply_depositor_metadata('mjg36')
+      # characterize method saves
+      @myfile.characterize
+      @myfile.reload
+    end
+
+    it "should return expected results after a save" do
+      expect(@myfile.file_size).to eq ['218882']
+      expect(@myfile.original_checksum).to eq ['5a2d761cab7c15b2b3bb3465ce64586d']
+
+      expect(@myfile.characterization_terms[:format_label]).to eq ["Portable Document Format"]
+      expect(@myfile.characterization_terms[:mime_type]).to eq "application/pdf"
+      expect(@myfile.characterization_terms[:file_size]).to eq ["218882"]
+      expect(@myfile.characterization_terms[:original_checksum]).to eq ["5a2d761cab7c15b2b3bb3465ce64586d"]
+      expect(@myfile.characterization_terms.keys).to include(:last_modified, :filename)
+
+      expect(@myfile.title).to include("Microsoft Word - sample.pdf.docx")
+      expect(@myfile.filename[0]).to eq 'sufia_test4.pdf'
+
+      @myfile.append_metadata
+      expect(@myfile.format_label).to eq ["Portable Document Format"]
+      expect(@myfile.title).to include("Microsoft Word - sample.pdf.docx")
+
+      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

data/spec/models/generic_file/web_form_spec.rb

@@ -23,7 +23,7 @@ describe GenericFile, :type => :model do
   describe "accessible_attributes" do
     it "should have a list" do
       expect(subject.accessible_attributes).to include(:part_of, :resource_type, :title, :creator, :contributor, :description,
-        :tag, :rights, :publisher, :date_created, :subject, :language, :identifier, :based_near, :related_url, :permissions)
+        :tag, :rights, :publisher, :date_created, :subject, :language, :identifier, :based_near, :related_url, :permissions_attributes)
     end
 
     it "should sanitize them" do

data/spec/models/generic_file_spec.rb

@@ -12,9 +12,6 @@ describe GenericFile, :type => :model do
     before do
       @transfer_to = FactoryGirl.find_or_create(:jill)
     end
-    after do
-      @file.destroy
-    end
 
     it "transfers the request" do
       @file.on_behalf_of = @transfer_to.user_key
@@ -36,12 +33,6 @@ describe GenericFile, :type => :model do
     end
   end
 
-  subject { GenericFile.new }
-
-  before do
-    subject.apply_depositor_metadata('jcoyne')
-  end
-
   describe '#to_s' do
     it 'uses the provided titles' do
       subject.title = ["Hello", "World"]
@@ -63,76 +54,84 @@ describe GenericFile, :type => :model do
 
   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)
+      expect(Sufia::IdService).to receive(:mint)
+      subject.assign_pid
     end
   end
 
   describe "mime type recognition" do
-    context "when image?" do
-      it "should be true for jpeg2000" do
-        subject.mime_type = 'image/jp2'
-        expect(subject).to be_image
+    context "#image?" do
+      context "when image/jp2" do
+        before { subject.mime_type = 'image/jp2' }
+        it { should be_image }
       end
-      it "should be true for jpeg" do
-        subject.mime_type = 'image/jpg'
-        expect(subject).to be_image
+      context "when image/jpg" do
+        before { subject.mime_type = 'image/jpg' }
+        it { should be_image }
       end
-      it "should be true for png" do
-        subject.mime_type = 'image/png'
-        expect(subject).to be_image
+      context "when image/png" do
+        before { subject.mime_type = 'image/png' }
+        it { should be_image }
       end
-      it "should be true for tiff" do
-        subject.mime_type = 'image/tiff'
-        expect(subject).to be_image
+      context "when image/tiff" do
+        before { subject.mime_type = 'image/tiff' }
+        it { should be_image }
       end
     end
-    context "when pdf?" do
-      it "should be true for pdf" do
-        subject.mime_type = 'application/pdf'
-        expect(subject).to be_pdf
-      end
+
+    describe "#pdf?" do
+      before { subject.mime_type = 'application/pdf' }
+      it { should be_pdf }
     end
-    context "when audio?" do
-      it "should be true for wav" do
-        subject.mime_type = 'audio/x-wave'
-        expect(subject).to be_audio
-        subject.mime_type = 'audio/x-wav'
-        expect(subject).to be_audio
+
+    describe "#audio?" do
+      context "when x-wave" do
+        before { subject.mime_type = 'audio/x-wave' }
+        it { should be_audio }
+      end
+      context "when x-wav" do
+        before { subject.mime_type = 'audio/x-wav' }
+        it { should be_audio }
       end
-      it "should be true for mpeg" do
-        subject.mime_type = 'audio/mpeg'
-        expect(subject).to be_audio
-        subject.mime_type = 'audio/mp3'
-        expect(subject).to be_audio
+      context "when mpeg" do
+        before { subject.mime_type = 'audio/mpeg' }
+        it { should be_audio }
       end
-      it "should be true for ogg" do
-        subject.mime_type = 'audio/ogg'
-        expect(subject).to be_audio
+      context "when mp3" do
+        before { subject.mime_type = 'audio/mp3' }
+        it { should be_audio }
+      end
+      context "when ogg" do
+        before { subject.mime_type = 'audio/ogg' }
+        it { should be_audio }
       end
     end
-    context "when video?" do
-      it "should be true for avi" do
-        subject.mime_type = 'video/avi'
-        expect(subject).to be_video
+
+    describe "#video?" do
+      context "should be true for avi" do
+        before { subject.mime_type = 'video/avi' }
+        it { should be_video }
       end
-      it "should be true for webm" do
-        subject.mime_type = 'video/webm'
-        expect(subject).to be_video
+
+      context "should be true for webm" do
+        before { subject.mime_type = 'video/webm' }
+        it { should be_video }
+      end
+      context "should be true for mp4" do
+        before { subject.mime_type = 'video/mp4' }
+        it { should be_video }
       end
-      it "should be true for mpeg" do
-        subject.mime_type = 'video/mp4'
-        expect(subject).to be_video
-        subject.mime_type = 'video/mpeg'
-        expect(subject).to be_video
+      context "should be true for mpeg" do
+        before { subject.mime_type = 'video/mpeg' }
+        it { should be_video }
       end
-      it "should be true for quicktime" do
-        subject.mime_type = 'video/quicktime'
-        expect(subject).to be_video
+      context "should be true for quicktime" do
+        before { subject.mime_type = 'video/quicktime' }
+        it { should be_video }
       end
-      it "should be true for mxf" do
-        subject.mime_type = 'application/mxf'
-        expect(subject).to be_video
+      context "should be true for mxf" do
+        before { subject.mime_type = 'application/mxf' }
+        it { should be_video }
       end
     end
   end
@@ -153,82 +152,42 @@ describe GenericFile, :type => :model do
 
   end
 
-  describe "attributes" do
-    it "should have rightsMetadata" do
-      expect(subject.rightsMetadata).to be_instance_of ParanoidRightsDatastream
-    end
-    it "should have properties datastream for depositor" do
-      expect(subject.properties).to be_instance_of PropertiesDatastream
-    end
-    it "should have apply_depositor_metadata" do
-      expect(subject.rightsMetadata.edit_access).to eq(['jcoyne'])
-      expect(subject.depositor).to eq('jcoyne')
+  describe "#apply_depositor_metadata" do
+    before { subject.apply_depositor_metadata('jcoyne') }
+
+    it "should grant edit access and record the depositor" do
+      expect(subject.edit_users).to eq ['jcoyne']
+      expect(subject.depositor).to eq 'jcoyne'
     end
+  end
+
+  describe "attributes" do
     it "should have a set of permissions" do
       subject.read_groups=['group1', 'group2']
       subject.edit_users=['user1']
       subject.read_users=['user2', 'user3']
-      expect(subject.permissions).to eq([{type: "group", access: "read", name: "group1"},
+      expect(subject.permissions.map(&:to_hash)).to match_array [
+          {type: "group", access: "read", name: "group1"},
           {type: "group", access: "read", name: "group2"},
-          {type: "user", access: "read", name: "user2"},
-          {type: "user", access: "read", name: "user3"},
-          {type: "user", access: "edit", name: "user1"}])
-    end
-    describe "updating permissions" do
-      it "should create new group permissions" do
-        subject.permissions = {new_group_name: {'group1'=>'read'}}
-        expect(subject.permissions).to eq([{type: "group", access: "read", name: "group1"},
-                                     {type: "user", access: "edit", name: "jcoyne"}])
-      end
-      it "should create new user permissions" do
-        subject.permissions = {new_user_name: {'user1'=>'read'}}
-        expect(subject.permissions).to eq([{type: "user", access: "read", name: "user1"},
-                                     {type: "user", access: "edit", name: "jcoyne"}])
-      end
-      it "should not replace existing groups" do
-        subject.permissions = {new_group_name: {'group1' => 'read'}}
-        subject.permissions = {new_group_name: {'group2' => 'read'}}
-        expect(subject.permissions).to eq([{type: "group", access: "read", name: "group1"},
-                                     {type: "group", access: "read", name: "group2"},
-                                     {type: "user", access: "edit", name: "jcoyne"}])
-      end
-      it "should not replace existing users" do
-        subject.permissions = {new_user_name:{'user1'=>'read'}}
-        subject.permissions = {new_user_name:{'user2'=>'read'}}
-        expect(subject.permissions).to eq([{type: "user", access: "read", name: "user1"},
-                                     {type: "user", access: "read", name: "user2"},
-                                     {type: "user", access: "edit", name: "jcoyne"}])
-      end
-      it "should update permissions on existing users" do
-        subject.permissions = {new_user_name:{'user1'=>'read'}}
-        subject.permissions = {user:{'user1'=>'edit'}}
-        expect(subject.permissions).to eq([{type: "user", access: "edit", name: "user1"},
-                                     {type: "user", access: "edit", name: "jcoyne"}])
-      end
-      it "should update permissions on existing groups" do
-        subject.permissions = {new_group_name:{'group1'=>'read'}}
-        subject.permissions = {group:{'group1'=>'edit'}}
-        expect(subject.permissions).to eq([{type: "group", access: "edit", name: "group1"},
-                                     {type: "user", access: "edit", name: "jcoyne"}])
-      end
+          {type: "person", access: "read", name: "user2"},
+          {type: "person", access: "read", name: "user3"},
+          {type: "person", access: "edit", name: "user1"}]
     end
+
     it "should have a characterization datastream" do
       expect(subject.characterization).to be_kind_of FitsDatastream
     end
-    it "should have a dc desc metadata" do
-      expect(subject.descMetadata).to be_kind_of GenericFileRdfDatastream
-    end
+
     it "should have content datastream" do
       subject.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
       expect(subject.content).to be_kind_of FileContentDatastream
     end
   end
-  describe "delegations" do
-    it "should delegate methods to properties metadata" do
+
+  describe "metadata" do
+    it "should have descriptive metadata" do
       expect(subject).to respond_to(:relative_path)
       expect(subject).to respond_to(:depositor)
-    end
-    it "should delegate methods to descriptive metadata" do
       expect(subject).to respond_to(:related_url)
       expect(subject).to respond_to(:based_near)
       expect(subject).to respond_to(:part_of)
@@ -259,59 +218,54 @@ describe GenericFile, :type => :model do
       expect(subject).to respond_to(:page_count)
     end
     it "should redefine to_param to make redis keys more recognizable" do
-      expect(subject.to_param).to eq(subject.noid)
+      expect(subject.to_param).to eq subject.noid
     end
+
     describe "that have been saved" do
-      # This file has no content, so it doesn't characterize
-      # before(:each) do
-      #   Sufia.queue.should_receive(:push).once
-      # end
-      after(:each) do
-        unless subject.inner_object.class == ActiveFedora::UnsavedDigitalObject
-          begin
-            subject.delete
-          rescue ActiveFedora::ObjectNotFoundError
-            # do nothing
-          end
-        end
-      end
+      before { subject.apply_depositor_metadata('jcoyne') }
+
       it "should have activity stream-related methods defined" do
-        subject.save
+        subject.save!
         f = subject.reload
         expect(f).to respond_to(:stream)
         expect(f).to respond_to(:events)
         expect(f).to respond_to(:create_event)
         expect(f).to 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.save
         f = subject.reload
-        expect(f.related_url).to eq(["http://example.org/"])
-        expect(f.creator).to eq(["John Doe"])
-        expect(f.title).to eq(["New work"])
+        expect(f.related_url).to eq ["http://example.org/"]
+        expect(f.creator).to eq ["John Doe"]
+        expect(f.title).to eq ["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.save
+        subject.save!
         f = subject.reload
-        expect(f.creator).to eq(["John Doe"])
-        expect(f.title).to eq(["New work"])
+        expect(f.creator).to eq ["John Doe"]
+        expect(f.title).to eq ["New work"]
         f.creator = ["Jane Doe"]
-        f.title << "Newer work"
+        f.title += ["Newer work"]
         f.save
         f = subject.reload
-        expect(f.creator).to eq(["Jane Doe"])
-        expect(f.title).to eq(["New work", "Newer work"])
+        expect(f.creator).to eq ["Jane Doe"]
+        # TODO: Is order important?
+        expect(f.title).to include("New work")
+        expect(f.title).to include("Newer work")
       end
     end
   end
+
   describe "to_solr" do
     before do
-      allow(subject).to receive(:pid).and_return('stubbed_pid')
+      allow(subject).to receive(:id).and_return('stubbed_pid')
       subject.part_of = ["Arabiana"]
       subject.contributor = ["Mohammad"]
       subject.creator = ["Allah"]
@@ -332,28 +286,29 @@ describe GenericFile, :type => :model do
       subject.format_label = ["JPEG Image"]
       subject.full_text.content = 'abcxyz'
     end
+
     it "supports to_solr" do
       local = subject.to_solr
-      expect(local[Solrizer.solr_name("desc_metadata__part_of")]).to be_nil
-      expect(local[Solrizer.solr_name("desc_metadata__date_uploaded")]).to be_nil
-      expect(local[Solrizer.solr_name("desc_metadata__date_modified")]).to be_nil
-      expect(local[Solrizer.solr_name("desc_metadata__date_uploaded", :stored_sortable, type: :date)]).to eq '2011-01-01T00:00:00Z'
-      expect(local[Solrizer.solr_name("desc_metadata__date_modified", :stored_sortable, type: :date)]).to eq '2012-01-01T00:00:00Z'
-      expect(local[Solrizer.solr_name("desc_metadata__rights")]).to eq ["Wide open, buddy."]
-      expect(local[Solrizer.solr_name("desc_metadata__related_url")]).to eq ["http://example.org/TheWork/"]
-      expect(local[Solrizer.solr_name("desc_metadata__contributor")]).to eq ["Mohammad"]
-      expect(local[Solrizer.solr_name("desc_metadata__creator")]).to eq ["Allah"]
-      expect(local[Solrizer.solr_name("desc_metadata__title")]).to eq ["The Work"]
-      expect(local["desc_metadata__title_sim"]).to eq ["The Work"]
-      expect(local[Solrizer.solr_name("desc_metadata__description")]).to eq ["The work by Allah"]
-      expect(local[Solrizer.solr_name("desc_metadata__publisher")]).to eq ["Vertigo Comics"]
-      expect(local[Solrizer.solr_name("desc_metadata__subject")]).to eq ["Theology"]
-      expect(local[Solrizer.solr_name("desc_metadata__language")]).to eq ["Arabic"]
-      expect(local[Solrizer.solr_name("desc_metadata__date_created")]).to eq ["1200-01-01"]
-      expect(local[Solrizer.solr_name("desc_metadata__resource_type")]).to eq ["Book"]
+      expect(local[Solrizer.solr_name("part_of")]).to be_nil
+      expect(local[Solrizer.solr_name("date_uploaded")]).to be_nil
+      expect(local[Solrizer.solr_name("date_modified")]).to be_nil
+      expect(local[Solrizer.solr_name("date_uploaded", :stored_sortable, type: :date)]).to eq '2011-01-01T00:00:00Z'
+      expect(local[Solrizer.solr_name("date_modified", :stored_sortable, type: :date)]).to eq '2012-01-01T00:00:00Z'
+      expect(local[Solrizer.solr_name("rights")]).to eq ["Wide open, buddy."]
+      expect(local[Solrizer.solr_name("related_url")]).to eq ["http://example.org/TheWork/"]
+      expect(local[Solrizer.solr_name("contributor")]).to eq ["Mohammad"]
+      expect(local[Solrizer.solr_name("creator")]).to eq ["Allah"]
+      expect(local[Solrizer.solr_name("title")]).to eq ["The Work"]
+      expect(local[Solrizer.solr_name("title", :facetable)]).to eq ["The Work"]
+      expect(local[Solrizer.solr_name("description")]).to eq ["The work by Allah"]
+      expect(local[Solrizer.solr_name("publisher")]).to eq ["Vertigo Comics"]
+      expect(local[Solrizer.solr_name("subject")]).to eq ["Theology"]
+      expect(local[Solrizer.solr_name("language")]).to eq ["Arabic"]
+      expect(local[Solrizer.solr_name("date_created")]).to eq ["1200-01-01"]
+      expect(local[Solrizer.solr_name("resource_type")]).to eq ["Book"]
       expect(local[Solrizer.solr_name("file_format")]).to eq "jpeg (JPEG Image)"
-      expect(local[Solrizer.solr_name("desc_metadata__identifier")]).to eq ["urn:isbn:1234567890"]
-      expect(local[Solrizer.solr_name("desc_metadata__based_near")]).to eq ["Medina, Saudi Arabia"]
+      expect(local[Solrizer.solr_name("identifier")]).to eq ["urn:isbn:1234567890"]
+      expect(local[Solrizer.solr_name("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')
@@ -366,26 +321,23 @@ describe GenericFile, :type => :model do
   end
   it "should support setting and getting the relative_path value" do
     subject.relative_path = "documents/research/NSF/2010"
-    expect(subject.relative_path).to eq("documents/research/NSF/2010")
+    expect(subject.relative_path).to eq "documents/research/NSF/2010"
   end
   describe "create_thumbnail" do
     before do
       @f = GenericFile.new
       @f.apply_depositor_metadata('mjg36')
     end
-    after do
-      @f.delete
-    end
     describe "with a video", if: Sufia.config.enable_ffmpeg do
       before do
-        allow(@f).to receive_messages(mime_type: 'video/quicktime')  #Would get set by the characterization job
+        allow(@f).to receive(mime_type: 'video/quicktime')  #Would get set by the characterization job
         @f.add_file(File.open("#{fixture_path}/countdown.avi", 'rb'), 'content', 'countdown.avi')
         @f.save
       end
       it "should make a png thumbnail" do
         @f.create_thumbnail
-        expect(@f.thumbnail.content.size).to eq(4768) # this is a bad test. I just want to show that it did something.
-        expect(@f.thumbnail.mimeType).to eq('image/png')
+        expect(@f.thumbnail.content.size).to eq 4768 # this is a bad test. I just want to show that it did something.
+        expect(@f.thumbnail.mime_type).to eq 'image/png'
       end
     end
   end
@@ -407,84 +359,6 @@ describe GenericFile, :type => :model do
     end
   end
 
-  describe "audit" do
-    before do
-      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)
-      f.save!
-      @f = f.reload
-    end
-    it "should schedule a audit job for each datastream" do
-      s0 = double('zero')
-      expect(AuditJob).to receive(:new).with(@f.pid, 'descMetadata', "descMetadata.0").and_return(s0)
-      expect(Sufia.queue).to receive(:push).with(s0)
-      s1 = double('one')
-      expect(AuditJob).to receive(:new).with(@f.pid, 'DC', "DC1.0").and_return(s1)
-      expect(Sufia.queue).to receive(:push).with(s1)
-      s2 = double('two')
-      expect(AuditJob).to receive(:new).with(@f.pid, 'RELS-EXT', "RELS-EXT.0").and_return(s2)
-      expect(Sufia.queue).to receive(:push).with(s2)
-      s3 = double('three')
-      expect(AuditJob).to receive(:new).with(@f.pid, 'rightsMetadata', "rightsMetadata.0").and_return(s3)
-      expect(Sufia.queue).to receive(:push).with(s3)
-      s4 = double('four')
-      expect(AuditJob).to receive(:new).with(@f.pid, 'properties', "properties.0").and_return(s4)
-      expect(Sufia.queue).to receive(:push).with(s4)
-      s5 = double('five')
-      expect(AuditJob).to receive(:new).with(@f.pid, 'content', "content.0").and_return(s5)
-      expect(Sufia.queue).to receive(:push).with(s5)
-      @f.audit!
-    end
-    it "should log a failing audit" do
-      @f.datastreams.each { |ds| allow(ds).to receive(:dsChecksumValid).and_return(false) }
-      allow(GenericFile).to receive(:run_audit).and_return(double(:respose, pass:1, created_at: '2005-12-20', pid: 'foo:123', dsid: 'foo', version: '1'))
-      @f.audit!
-      expect(ChecksumAuditLog.all).to be_all { |cal| cal.pass == 0 }
-    end
-    it "should log a passing audit" do
-      allow(GenericFile).to receive(:run_audit).and_return(double(:respose, pass:1, created_at: '2005-12-20', pid: 'foo:123', dsid: 'foo', version: '1'))
-      @f.audit!
-      expect(ChecksumAuditLog.all).to be_all { |cal| cal.pass == 1 }
-    end
-
-    it "should return true on audit_status" do
-      expect(@f.audit_stat).to be_truthy
-    end
-  end
-
-  describe "run_audit" do
-    before do
-      @f = GenericFile.new
-      @f.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
-      @f.apply_depositor_metadata('mjg36')
-      @f.save!
-      @version = @f.datastreams['content'].versions.first
-      @old = ChecksumAuditLog.create(pid: @f.pid, dsid: @version.dsid, version: @version.versionID, pass: 1, created_at: 2.minutes.ago)
-      @new = ChecksumAuditLog.create(pid: @f.pid, dsid: @version.dsid, version: @version.versionID, pass: 0)
-    end
-    it "should not prune failed audits" do
-      expect(@version).to receive(:dsChecksumValid).and_return(true)
-      GenericFile.run_audit(@version)
-
-      expect(@version).to receive(:dsChecksumValid).and_return(false)
-      GenericFile.run_audit(@version)
-
-      expect(@version).to receive(:dsChecksumValid).and_return(false)
-      GenericFile.run_audit(@version)
-
-      expect(@version).to receive(:dsChecksumValid).and_return(true)
-      GenericFile.run_audit(@version)
-
-      expect(@version).to receive(:dsChecksumValid).and_return(false)
-      GenericFile.run_audit(@version)
-
-      expect(@f.logs(@version.dsid).map(&:pass)).to eq([0, 1, 0, 0, 1, 0, 1])
-    end
-
-  end
-
   describe "#related_files" do
     let!(:f1) do
       GenericFile.new.tap do |f|
@@ -527,551 +401,180 @@ describe GenericFile, :type => :model do
       end
     end
   end
+
   describe "noid integration" do
-    before(:all) do
-      @new_file = GenericFile.new(pid: 'ns:123')
-      @new_file.apply_depositor_metadata('mjg36')
-      @new_file.save
-    end
-    after(:all) do
-      @new_file.delete
-    end
-    it "should support the noid method" do
-      expect(@new_file).to respond_to(:noid)
-    end
+    subject { GenericFile.new(id: 'wd3763094') }
+
     it "should return the expected identifier" do
-      expect(@new_file.noid).to eq('123')
+      expect(subject.noid).to eq 'wd3763094'
     end
-    it "should work outside of an instance" do
-      new_id = Sufia::IdService.mint
-      noid = new_id.split(':').last
-      expect(Sufia::Noid.noidify(new_id)).to eq(noid)
-    end
-  end
-  describe "characterize" do
-    it "should return expected results when called", unless: $in_travis do
-      subject.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
-      subject.characterize
-      doc = Nokogiri::XML.parse(subject.characterization.content)
-      expect(doc.root.xpath('//ns:imageWidth/text()', {'ns'=>'http://hul.harvard.edu/ois/xml/ns/fits/fits_output'}).inner_text).to eq('50')
+
+    it "should have a tree-like URL" do
+      expect(subject.uri).to eq 'http://localhost:8983/fedora/rest/test/wd/37/63/09/wd3763094'
     end
-    context "after characterization" do
-      before(:all) do
-        myfile = GenericFile.new
-        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 = myfile.reload
-      end
-      after(:all) do
-        @myfile.destroy
-      end
-      it "should return expected results after a save" do
-        expect(@myfile.file_size).to eq(['218882'])
-        expect(@myfile.original_checksum).to eq(['5a2d761cab7c15b2b3bb3465ce64586d'])
-      end
-      it "should return a hash of all populated values from the characterization terminology" do
-        expect(@myfile.characterization_terms[:format_label]).to eq(["Portable Document Format"])
-        expect(@myfile.characterization_terms[:mime_type]).to eq("application/pdf")
-        expect(@myfile.characterization_terms[:file_size]).to eq(["218882"])
-        expect(@myfile.characterization_terms[:original_checksum]).to eq(["5a2d761cab7c15b2b3bb3465ce64586d"])
-        expect(@myfile.characterization_terms.keys).to include(:last_modified)
-        expect(@myfile.characterization_terms.keys).to include(:filename)
-      end
-      it "should append metadata from the characterization" do
-        expect(@myfile.title).to include("Microsoft Word - sample.pdf.docx")
-        expect(@myfile.filename[0]).to eq(@myfile.label)
-      end
-      it "should append each term only once" do
-        @myfile.append_metadata
-        expect(@myfile.format_label).to eq(["Portable Document Format"])
-        expect(@myfile.title).to 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")
+
+    context "when a url is provided" do
+      let(:url) { 'http://localhost:8983/fedora/rest/test/wd/37/63/09/wd3763094' }
+      it "should be able to get the id" do
+        expect(GenericFile.uri_to_id(url)).to eq 'wd3763094'
       end
     end
   end
-  describe "label" do
-    it "should set the inner label" do
-      subject.label = "My New Label"
-      expect(subject.inner_object.label).to eq("My New Label")
-    end
-  end
-  context "with rightsMetadata" do
+
+  context "with access control metadata" do
     subject do
-      m = GenericFile.new()
-      m.rightsMetadata.update_permissions("person"=>{"person1"=>"read","person2"=>"read"}, "group"=>{'group-6' => 'read', "group-7"=>'read', 'group-8'=>'edit'})
-      #m.save
-      m
+      GenericFile.new do |m|
+        m.apply_depositor_metadata('jcoyne')
+        m.permissions_attributes = [{type: 'person', access: 'read', name: "person1"},
+                                    {type: 'person', access: 'read', name: "person2"},
+                                    {type: 'group', access: 'read', name: "group-6"},
+                                    {type: 'group', access: 'read', name: "group-7"},
+                                    {type: 'group', access: 'edit', name: "group-8"}]
+      end
     end
+
     it "should have read groups accessor" do
-      expect(subject.read_groups).to eq(['group-6', 'group-7'])
+      expect(subject.read_groups).to eq ['group-6', 'group-7']
     end
+
     it "should have read groups string accessor" do
-      expect(subject.read_groups_string).to eq('group-6, group-7')
+      expect(subject.read_groups_string).to eq 'group-6, group-7'
     end
+
     it "should have read groups writer" do
       subject.read_groups = ['group-2', 'group-3']
-      expect(subject.rightsMetadata.groups).to eq({'group-2' => 'read', 'group-3'=>'read', 'group-8' => 'edit'})
-      expect(subject.rightsMetadata.users).to eq({"person1"=>"read","person2"=>"read", 'jcoyne' => 'edit'})
+      expect(subject.read_groups).to eq ['group-2', 'group-3']
     end
 
     it "should have read groups string writer" do
       subject.read_groups_string = 'umg/up.dlt.staff, group-3'
-      expect(subject.rightsMetadata.groups).to eq({'umg/up.dlt.staff' => 'read', 'group-3'=>'read', 'group-8' => 'edit'})
-      expect(subject.rightsMetadata.users).to eq({"person1"=>"read","person2"=>"read", 'jcoyne' => 'edit'})
+      expect(subject.read_groups).to eq ['umg/up.dlt.staff', 'group-3']
+      expect(subject.edit_groups).to eq ['group-8']
+      expect(subject.read_users).to eq ['person1', 'person2']
+      expect(subject.edit_users).to eq ['jcoyne']
     end
+
     it "should only revoke eligible groups" do
       subject.set_read_groups(['group-2', 'group-3'], ['group-6'])
       # 'group-7' is not eligible to be revoked
-      expect(subject.rightsMetadata.groups).to eq({'group-2' => 'read', 'group-3'=>'read', 'group-7' => 'read', 'group-8' => 'edit'})
-      expect(subject.rightsMetadata.users).to eq({"person1"=>"read","person2"=>"read", 'jcoyne' => 'edit'})
+      expect(subject.read_groups).to match_array ['group-2', 'group-3', 'group-7']
+      expect(subject.edit_groups).to eq ['group-8']
+      expect(subject.read_users).to match_array ['person1', 'person2']
+      expect(subject.edit_users).to eq ['jcoyne']
     end
   end
+
   describe "permissions validation" do
-    context "depositor must have edit access" do
-      before(:each) do
-        @file = GenericFile.new
-        @file.apply_depositor_metadata('mjg36')
-        @rightsmd = @file.rightsMetadata
-      end
-      before(:all) do
-        @rights_xml = <<-RIGHTS
-<rightsMetadata xmlns="http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1" version="0.1">
-  <copyright>
-    <human></human>
-    <machine></machine>
-  </copyright>
-  <access type="read">
-    <human></human>
-    <machine></machine>
-  </access>
-  <access type="read">
-    <human></human>
-    <machine>
-      <person>mjg36</person>
-    </machine>
-  </access>
-  <access type="edit">
-    <human></human>
-    <machine></machine>
-  </access>
-  <embargo>
-    <human></human>
-    <machine></machine>
-  </embargo>
-</rightsMetadata>
-      RIGHTS
-      end
-      it "should work via permissions=()" do
-        @file.permissions = {user: {'mjg36' => 'read'}}
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_users)
-        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via update_attributes" do
-        # automatically triggers save
-        expect { @file.update_attributes(read_users_string: 'mjg36') }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_users)
-        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via update_indexed_attributes" do
-        @rightsmd.update_indexed_attributes([:edit_access, :person] => '')
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_users)
-        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via permissions()" do
-        @rightsmd.permissions({person: "mjg36"}, "read")
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_users)
-        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via update_permissions()" do
-        @rightsmd.update_permissions({"person" => {"mjg36" => "read"}})
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_users)
-        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via content=()" do
-        @rightsmd.content=(@rights_xml)
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_users)
-        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via ng_xml=()" do
-        @rightsmd.ng_xml=(Nokogiri::XML::Document.parse(@rights_xml))
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_users)
-        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
-        expect(@file).to_not be_valid
+    before { subject.apply_depositor_metadata('mjg36') }
+
+    context "when the depositor does not have edit access" do
+      before do
+        subject.permissions = [ Hydra::AccessControls::Permission.new(type: 'person', name: 'mjg36', access: 'read')]
       end
-      it "should work via update_values()" do
-        @rightsmd.update_values([:edit_access, :person] => '')
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_users)
-        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
-        expect(@file).to_not be_valid
+      it "should be invalid" do
+        expect(subject).to_not be_valid
+        expect(subject.errors[:edit_users]).to include('Depositor must have edit access')
       end
     end
-    context "public must not have edit access" do
-      before(:each) do
-        @file = GenericFile.new
-        @file.apply_depositor_metadata('mjg36')
-        @file.read_groups = ['public']
-        @rightsmd = @file.rightsMetadata
-      end
-      before(:all) do
-        @rights_xml = <<-RIGHTS
-<rightsMetadata xmlns="http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1" version="0.1">
-  <copyright>
-    <human></human>
-    <machine></machine>
-  </copyright>
-  <access type="read">
-    <human></human>
-    <machine></machine>
-  </access>
-  <access type="read">
-    <human></human>
-    <machine></machine>
-  </access>
-  <access type="edit">
-    <human></human>
-    <machine>
-      <group>public</group>
-    </machine>
-  </access>
-  <embargo>
-    <human></human>
-    <machine></machine>
-  </embargo>
-</rightsMetadata>
-        RIGHTS
-      end
-      it "should work via permissions=()" do
-        @file.permissions = {group: {'public' => 'edit'}}
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via update_attributes" do
-        # automatically triggers save
-        expect { @file.update_attributes(edit_groups_string: 'public') }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via update_indexed_attributes" do
-        @rightsmd.update_indexed_attributes([:edit_access, :group] => 'public')
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via permissions()" do
-        @rightsmd.permissions({group: "public"}, "edit")
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via update_permissions()" do
-        @rightsmd.update_permissions({"group" => {"public" => "edit"}})
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via content=()" do
-        @rightsmd.content=(@rights_xml)
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via ng_xml=()" do
-        @rightsmd.ng_xml=(Nokogiri::XML::Document.parse(@rights_xml))
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via update_values()" do
-        @rightsmd.update_values([:edit_access, :group] => 'public')
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
-        expect(@file).to_not be_valid
+
+    context "when the public has edit access" do
+      before { subject.edit_groups = ['public'] }
+
+      it "should be invalid" do
+        expect(subject).to_not be_valid
+        expect(subject.errors[:edit_groups]).to include('Public cannot have edit access')
       end
     end
-    context "registered must not have edit access" do
-      before(:each) do
-        @file = GenericFile.new
-        @file.apply_depositor_metadata('mjg36')
-        @file.read_groups = ['registered']
-        @rightsmd = @file.rightsMetadata
-      end
-      before(:all) do
-        @rights_xml = <<-RIGHTS
-<rightsMetadata xmlns="http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1" version="0.1">
-  <copyright>
-    <human></human>
-    <machine></machine>
-  </copyright>
-  <access type="read">
-    <human></human>
-    <machine></machine>
-  </access>
-  <access type="read">
-    <human></human>
-    <machine></machine>
-  </access>
-  <access type="edit">
-    <human></human>
-    <machine>
-      <group>registered</group>
-    </machine>
-  </access>
-  <embargo>
-    <human></human>
-    <machine></machine>
-  </embargo>
-</rightsMetadata>
-        RIGHTS
-      end
-      it "should work via permissions=()" do
-        @file.permissions = {group: {'registered' => 'edit'}}
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via update_attributes" do
-        # automatically triggers save
-        expect { @file.update_attributes(edit_groups_string: 'registered') }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via update_indexed_attributes" do
-        @rightsmd.update_indexed_attributes([:edit_access, :group] => 'registered')
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via permissions()" do
-        @rightsmd.permissions({group: "registered"}, "edit")
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via update_permissions()" do
-        @rightsmd.update_permissions({"group" => {"registered" => "edit"}})
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via content=()" do
-        @rightsmd.content=(@rights_xml)
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via ng_xml=()" do
-        @rightsmd.ng_xml=(Nokogiri::XML::Document.parse(@rights_xml))
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
-        expect(@file).to_not be_valid
-      end
-      it "should work via update_values()" do
-        @rightsmd.update_values([:edit_access, :group] => 'registered')
-        expect { @file.save }.not_to raise_error
-        expect(@file).to be_new_record
-        expect(@file.errors).to include(:edit_groups)
-        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
-        expect(@file).to_not be_valid
+
+    context "when registered has edit access" do
+      before { subject.edit_groups = ['registered'] }
+
+      it "should be invalid" do
+        expect(subject).to_not be_valid
+        expect(subject.errors[:edit_groups]).to include('Registered cannot have edit access')
       end
     end
+
     context "everything is copacetic" do
-      before(:each) do
-        @file = GenericFile.new
-        @file.apply_depositor_metadata('mjg36')
-        @file.read_groups = ['public']
-        @rightsmd = @file.rightsMetadata
-      end
-      after(:each) do
-        @file.delete
-      end
-      before(:all) do
-        @rights_xml = <<-RIGHTS
-<rightsMetadata xmlns="http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1" version="0.1">
-  <copyright>
-    <human></human>
-    <machine></machine>
-  </copyright>
-  <access type="read">
-    <human></human>
-    <machine>
-      <group>public</group>
-      <group>registered</group>
-    </machine>
-  </access>
-  <access type="edit">
-    <human></human>
-    <machine>
-      <person>mjg36</person>
-    </machine>
-  </access>
-  <embargo>
-    <human></human>
-    <machine></machine>
-  </embargo>
-</rightsMetadata>
-      RIGHTS
-      end
-      it "should work via permissions=()" do
-        @file.permissions = {group: {'registered' => 'read'}}
-        expect { @file.save }.not_to raise_error
-        expect(@file).to_not be_new_record
-        expect(@file.errors).to be_empty
-        expect(@file).to be_valid
-      end
-      it "should work via update_attributes" do
-        # automatically triggers save
-        expect { @file.update_attributes(read_groups_string: 'registered') }.not_to raise_error
-        expect(@file).to_not be_new_record
-        expect(@file.errors).to be_empty
-        expect(@file).to be_valid
-      end
-      it "should work via update_indexed_attributes" do
-        @rightsmd.update_indexed_attributes([:read_access, :group] => 'registered')
-        expect { @file.save }.not_to raise_error
-        expect(@file).to_not be_new_record
-        expect(@file.errors).to be_empty
-        expect(@file).to be_valid
-      end
-      it "should work via permissions()" do
-        @rightsmd.permissions({group: "registered"}, "read")
-        expect { @file.save }.not_to raise_error
-        expect(@file).to_not be_new_record
-        expect(@file.errors).to be_empty
-        expect(@file).to be_valid
-      end
-      it "should work via update_permissions()" do
-        @rightsmd.update_permissions({"group" => {"registered" => "read"}})
-        expect { @file.save }.not_to raise_error
-        expect(@file).to_not be_new_record
-        expect(@file.errors).to be_empty
-        expect(@file).to be_valid
-      end
-      it "should work via content=()" do
-        @rightsmd.content=(@rights_xml)
-        expect { @file.save }.not_to raise_error
-        expect(@file).to_not be_new_record
-        expect(@file.errors).to be_empty
-        expect(@file).to be_valid
-      end
-      it "should work via ng_xml=()" do
-        @rightsmd.ng_xml=(Nokogiri::XML::Document.parse(@rights_xml))
-        expect { @file.save }.not_to raise_error
-        expect(@file).to_not be_new_record
-        expect(@file.errors).to be_empty
-        expect(@file).to be_valid
-      end
-      it "should work via update_values()" do
-        @rightsmd.update_values([:read_access, :group] => 'registered')
-        expect { @file.save }.not_to raise_error
-        expect(@file).to_not be_new_record
-        expect(@file.errors).to be_empty
-        expect(@file).to be_valid
+      it "should be valid" do
+        expect(subject).to be_valid
       end
     end
   end
+
   describe "file content validation" do
     context "when file contains a virus" do
       let(:f) { File.new(fixture_path + '/small_file.txt') }
-      after(:each) do
-        subject.destroy if subject.persisted?
+
+      before do
+        subject.add_file(f, 'content', 'small_file.txt')
+        subject.apply_depositor_metadata('mjg36')
       end
+
       it "populates the errors hash during validation" do
         allow(Sufia::GenericFile::Actor).to receive(:virus_check).and_raise(Sufia::VirusFoundError, "A virus was found in #{f.path}: EL CRAPO VIRUS")
-        subject.add_file(f, 'content', 'small_file.txt')
         subject.save
         expect(subject).not_to be_persisted
         expect(subject.errors.messages).to eq(base: ["A virus was found in #{f.path}: EL CRAPO VIRUS"])
       end
+
       it "does not save a new version of a GenericFile" do
-        subject.add_file(f, 'content', 'small_file.txt')
-        subject.save
+        subject.save!
         allow(Sufia::GenericFile::Actor).to receive(:virus_check).and_raise(Sufia::VirusFoundError)
         subject.add_file(File.new(fixture_path + '/sufia_generic_stub.txt') , 'content', 'sufia_generic_stub.txt')
         subject.save
-        expect(subject.reload.content.content).to eq("small\n")
+        expect(subject.reload.content.content).to eq "small\n"
       end
     end
   end
 
-  describe "should create a full to_solr record" do
+  describe "#remove_blank_assertions" do
     before do
-      subject.save
+      subject.title = ["foo"]
+      subject.description = [""]
+      subject.remove_blank_assertions
     end
-    after do
-      subject.destroy
+
+    it "should only change title" do
+      expect(subject.title).to eq(["foo"])
+      expect(subject.description).to be_empty
     end
-    it "gets both sets of data into solr" do
-     f1= GenericFile.find(subject.id)
-     f2 = GenericFile.find(subject.id)
-     f2.reload_on_save = true
-     f1.mime_type = "video/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)
-     expect(f1.to_solr[mime_type_key]).to eq([f1.mime_type])
-     expect(f1.to_solr[title_key]).to_not eq(f2.title)
-     f2.save
-     expect(f2.to_solr[mime_type_key]).to eq([f1.mime_type])
-     expect(f2.to_solr[title_key]).to eq(f2.title)
+  end
+
+  describe "to_solr record" do
+    let(:depositor) { 'jcoyne' }
+    subject do
+      GenericFile.new.tap do |f|
+        f.apply_depositor_metadata(depositor)
+        f.save
+      end
     end
+    let(:depositor_key) { Solrizer.solr_name("depositor") }
+    let(:title_key) { Solrizer.solr_name("title", :stored_searchable, type: :string) }
+    let(:title) { ["abc123"] }
+    let(:no_terms) { GenericFile.find(subject.id).to_solr }
+    let(:terms) { 
+      file = GenericFile.find(subject.id)
+      file.title = title
+      file.save
+      file.to_solr
+    }
+
+    context "without terms" do
+      specify "title is nil" do
+        expect(no_terms[title_key]).to be_nil
+      end
+    end
+
+    context "with terms" do
+      specify "depositor is set" do
+        expect(terms[depositor_key].first).to eql(depositor)
+      end
+      specify "title is set" do
+        expect(terms[title_key]).to eql(title)
+      end
+    end
+
   end
 
   describe "public?" do