sufia 5.0.0 → 6.0.0.beta1

data/spec/controllers/collections_controller_spec.rb

@@ -1,22 +1,15 @@
 require 'spec_helper'
 
-describe CollectionsController, :type => :controller do
-  before(:each) { @routes = Hydra::Collections::Engine.routes }
+describe CollectionsController do
+  routes { Hydra::Collections::Engine.routes }
   before do
-    allow(controller).to receive(:has_access?).and_return(true)
     allow_any_instance_of(User).to receive(:groups).and_return([])
   end
 
   let(:user) { FactoryGirl.create(:user) }
 
-  after (:all) do
-    Collection.destroy_all
-    GenericFile.destroy_all
-    User.destroy_all
-  end
-
   describe '#new' do
-    before do 
+    before do
       sign_in user
     end
 
@@ -27,16 +20,16 @@ describe CollectionsController, :type => :controller do
   end
 
   describe '#create' do
-    before do 
+    before do
       sign_in user
     end
 
     it "should create a Collection" do
-      expect(controller).to receive(:has_access?).and_return(true)
-      old_count = Collection.count
-      post :create, collection: {title: "My First Collection ", description: "The Description\r\n\r\nand more"}
-      expect(Collection.count).to eq(old_count+1)
+      expect {
+        post :create, collection: {title: "My First Collection ", description: "The Description\r\n\r\nand more"}
+      }.to change{ Collection.count }.by(1)
     end
+
     it "should create a Collection with files I can access" do
       @asset1 = GenericFile.new(title: ["First of the Assets"])
       @asset1.apply_depositor_metadata(user.user_key)
@@ -47,18 +40,12 @@ describe CollectionsController, :type => :controller do
       @asset3 = GenericFile.new(title: ["Third of the Assets"], depositor:'abc')
       @asset3.apply_depositor_metadata('abc')
       @asset3.save
-      expect(controller).to receive(:has_access?).and_return(true)
-      old_count = Collection.count
-      post :create, collection: { title: "My own Collection", description: "The Description\r\n\r\nand more" },
-        batch_document_ids: [@asset1.id, @asset2.id, @asset3.id]
-      expect(Collection.count).to eq(old_count+1)
+      expect {
+        post :create, collection: { title: "My own Collection", description: "The Description\r\n\r\nand more" },
+          batch_document_ids: [@asset1.id, @asset2.id, @asset3.id]
+      }.to change{ Collection.count }.by(1)
       collection = assigns(:collection)
-      expect(collection.members).to include (@asset1)
-      expect(collection.members).to include (@asset2)
-      expect(collection.members.to_a).not_to include (@asset3) # .to_a to avoid a call to any? which doesn't exist in AF::HABTM
-      @asset1.destroy
-      @asset2.destroy
-      @asset3.destroy
+      expect(collection.members).to match_array [@asset1, @asset2]
     end
 
     it "should add docs to collection if batch ids provided and add the collection id to the documents int he colledction" do
@@ -67,22 +54,22 @@ describe CollectionsController, :type => :controller do
       @asset1.save
       post :create, batch_document_ids: [@asset1.id],
         collection: { title: "My Secong Collection ", description: "The Description\r\n\r\nand more" }
-      expect(assigns[:collection].members).to eq([@asset1])
+      expect(assigns[:collection].members).to eq [@asset1]
       asset_results = ActiveFedora::SolrService.instance.conn.get "select", params:{fq:["id:\"#{@asset1.id}\""],fl:['id',Solrizer.solr_name(:collection)]}
-      expect(asset_results["response"]["numFound"]).to eq(1)
+      expect(asset_results["response"]["numFound"]).to eq 1
       doc = asset_results["response"]["docs"].first
-      expect(doc["id"]).to eq(@asset1.id)
-      afterupdate = GenericFile.find(@asset1.pid)
-      expect(doc[Solrizer.solr_name(:collection)]).to eq(afterupdate.to_solr[Solrizer.solr_name(:collection)])
+      expect(doc["id"]).to eq @asset1.id
+      afterupdate = GenericFile.find(@asset1.id)
+      expect(doc[Solrizer.solr_name(:collection)]).to eq afterupdate.to_solr[Solrizer.solr_name(:collection)]
     end
 
   end
 
   describe "#update" do
     before do
-      @collection = Collection.new(title: "Collection Title")
-      @collection.apply_depositor_metadata(user.user_key)
-      @collection.save
+      @collection = Collection.create(title: "Collection Title") do |collection|
+        collection.apply_depositor_metadata(user.user_key)
+      end
       @asset1 = GenericFile.new(title: ["First of the Assets"])
       @asset1.apply_depositor_metadata(user.user_key)
       @asset1.save
@@ -94,29 +81,23 @@ describe CollectionsController, :type => :controller do
       @asset3.save
       sign_in user
     end
-    after do
-      @collection.destroy
-      @asset1.destroy
-      @asset2.destroy
-      @asset3.destroy
-    end
 
     it "should set collection on members" do
-      put :update, id: @collection.id, collection: {members:"add"}, batch_document_ids: [@asset3.pid, @asset1.pid, @asset2.pid]
-      expect(response).to redirect_to Hydra::Collections::Engine.routes.url_helpers.collection_path(@collection.noid)
-      expect(assigns[:collection].members.map{|m| m.pid}.sort).to eq([@asset2, @asset3, @asset1].map {|m| m.pid}.sort)
-      asset_results = ActiveFedora::SolrService.instance.conn.get "select", params:{fq:["id:\"#{@asset2.pid}\""],fl:['id',Solrizer.solr_name(:collection)]}
-      expect(asset_results["response"]["numFound"]).to eq(1)
+      put :update, id: @collection, collection: {members:"add"}, batch_document_ids: [@asset3.id, @asset1.id, @asset2.id]
+      expect(response).to redirect_to routes.url_helpers.collection_path(@collection.noid)
+      expect(assigns[:collection].members).to match_array [@asset2, @asset3, @asset1]
+      asset_results = ActiveFedora::SolrService.instance.conn.get "select", params:{fq:["id:\"#{@asset2.id}\""],fl:['id',Solrizer.solr_name(:collection)]}
+      expect(asset_results["response"]["numFound"]).to eq 1
       doc = asset_results["response"]["docs"].first
-      expect(doc["id"]).to eq(@asset2.id)
-      afterupdate = GenericFile.find(@asset2.pid)
-      expect(doc[Solrizer.solr_name(:collection)]).to eq(afterupdate.to_solr[Solrizer.solr_name(:collection)])
-      put :update, id: @collection.id, collection: {members:"remove"}, batch_document_ids: [@asset2]
-      asset_results = ActiveFedora::SolrService.instance.conn.get "select", params:{fq:["id:\"#{@asset2.pid}\""],fl:['id',Solrizer.solr_name(:collection)]}
-      expect(asset_results["response"]["numFound"]).to eq(1)
+      expect(doc["id"]).to eq @asset2.id
+      afterupdate = GenericFile.find(@asset2.id)
+      expect(doc[Solrizer.solr_name(:collection)]).to eq afterupdate.to_solr[Solrizer.solr_name(:collection)]
+      put :update, id: @collection, collection: {members:"remove"}, batch_document_ids: [@asset2]
+      asset_results = ActiveFedora::SolrService.instance.conn.get "select", params:{fq:["id:\"#{@asset2.id}\""],fl:['id',Solrizer.solr_name(:collection)]}
+      expect(asset_results["response"]["numFound"]).to eq 1
       doc = asset_results["response"]["docs"].first
-      expect(doc["id"]).to eq(@asset2.pid)
-      afterupdate = GenericFile.find(@asset2.pid)
+      expect(doc["id"]).to eq @asset2.id
+      afterupdate = GenericFile.find(@asset2.id)
       expect(doc[Solrizer.solr_name(:collection)]).to be_nil
     end
   end
@@ -125,47 +106,39 @@ describe CollectionsController, :type => :controller do
     before do
       @asset1 = GenericFile.new(title: ["First of the Assets"])
       @asset1.apply_depositor_metadata(user.user_key)
-      @asset1.save!
       @asset2 = GenericFile.new(title: ["Second of the Assets"], depositor:user.user_key)
       @asset2.apply_depositor_metadata(user.user_key)
-      @asset2.save!
       @asset3 = GenericFile.new(title: ["Third of the Assets"], depositor:user.user_key)
       @asset3.apply_depositor_metadata(user.user_key)
-      @asset3.save!
       @asset4 = GenericFile.new(title: ["Third of the Assets"], depositor:user.user_key)
       @asset4.apply_depositor_metadata(user.user_key)
-      @asset4.save!
-      @collection = Collection.new
-      @collection.title = "My collection"
-      @collection.description = "My incredibly detailed description of the collection"
-      @collection.apply_depositor_metadata(user.user_key)
-      @collection.members = [@asset1,@asset2,@asset3]
-      @collection.save!
+      @collection = Collection.create(title: "My collection",
+                                   description: "My incredibly detailed description of the collection",
+                                   members: [@asset1,@asset2,@asset3]) do |collection|
+        collection.apply_depositor_metadata(user)
+      end
       allow(controller).to receive(:authorize!).and_return(true)
-      allow(controller).to receive(:apply_gated_search)
     end
     context "when signed in" do
-      before do 
+      before do
         sign_in user
       end
 
       it "should return the collection and its members" do
-        get :show, id: @collection.id
+        get :show, id: @collection
         expect(response).to be_successful
-        expect(assigns[:collection].title).to eq(@collection.title)
-        ids = assigns[:member_docs].map(&:id)
-        expect(ids).to include @asset1.pid, @asset2.pid, @asset3.pid
-        expect(ids).to_not include @asset4.pid
+        expect(assigns[:collection].title).to eq @collection.title
+        expect(assigns[:member_docs].map(&:id)).to match_array [@asset1, @asset2, @asset3].map(&:id)
       end
       it "should set the breadcrumb trail" do
         expect(controller).to receive(:add_breadcrumb).with(I18n.t('sufia.dashboard.title'), Sufia::Engine.routes.url_helpers.dashboard_index_path)
-        get :show, id: @collection.id
+        get :show, id: @collection
       end
     end
     context "not signed in" do
       it "should not show me files in the collection" do
-        get :show, id: @collection.id
-        expect(assigns[:member_docs].count).to eq(0)
+        get :show, id: @collection
+        expect(assigns[:member_docs].count).to eq 0
       end
     end
   end
@@ -178,7 +151,7 @@ describe CollectionsController, :type => :controller do
       sign_in user
     end
     it "should not show flash" do
-      get :edit, id: @collection.id
+      get :edit, id: @collection
       expect(flash[:notice]).to be_nil
     end
   end

data/spec/controllers/downloads_controller_spec.rb

@@ -3,56 +3,63 @@ require 'spec_helper'
 describe DownloadsController, :type => :controller do
 
   describe "with a file" do
-    before do
-      @f = GenericFile.new(pid: 'sufia:test1')
-      @f.apply_depositor_metadata('archivist1@example.com')
-      @f.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
-      @f.save!
+    let(:depositor) { FactoryGirl.find_or_create(:archivist) }
+    let(:file) do
+      GenericFile.new.tap do |f|
+        f.apply_depositor_metadata(depositor.user_key)
+        f.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
+        f.save!
+      end
     end
 
-    after do
-      @f.delete
-    end
+    before { allow_any_instance_of(User).to receive(:groups).and_return([]) }
 
     describe "when logged in as reader" do
       before do
-        sign_in FactoryGirl.find_or_create(:archivist)
-        allow_any_instance_of(User).to receive(:groups).and_return([])
-        allow(controller).to receive(:clear_session_user) ## Don't clear out the authenticated session
+        sign_in depositor
       end
       describe "show" do
-        it "should default to returning configured default download" do
-          expect(DownloadsController.default_content_dsid).to eq("content")
+        before do
           allow(controller).to receive(:render) # send_data calls render internally
-          expected_content = ActiveFedora::Base.find("sufia:test1", cast: true).content.content
+        end
+        let(:object) { ActiveFedora::Base.find(file.id) }
+        let(:expected_datastream) { object.content }
+        let(:expected_content) { expected_datastream.content }
+
+        it "should default to returning configured default download" do
+          expect(DownloadsController.default_content_dsid).to eq "content"
           expect(controller).to receive(:send_file_headers!).with({filename: 'world.png', disposition: 'inline', type: 'image/png' })
-          get "show", id: "test1"
-          expect(response.body).to eq(expected_content)
+          get "show", id: file
           expect(response).to be_success
+          expect(response.body).to eq expected_content
         end
-        it "should return requested datastreams" do
-          allow(controller).to receive(:render) # send_data calls render internally
-          expected_content = ActiveFedora::Base.find("sufia:test1", cast: true).descMetadata.content
-          expect(controller).to receive(:send_file_headers!).with(filename: 'descMetadata', disposition: 'inline', type: 'application/n-triples')
-          get "show", id: "test1", datastream_id: "descMetadata"
-          expect(response.body).to eq(expected_content)
-          expect(response).to be_success
+
+        context "when grabbing the characterization datastream" do
+          let(:expected_content) { "<?xml version=\"1.0\"?>\n<fits stuff=\"yep\"/>" }
+          before do
+            file.characterization.content = expected_content
+            file.save!
+          end
+
+          it "should return requested datastreams" do
+            get "show", id: file, datastream_id: "characterization"
+            expect(response).to be_success
+            expect(response.body).to eq expected_content
+          end
         end
+
         it "should support setting disposition to inline" do
-          allow(controller).to receive(:render) # send_data calls render internally
-          expected_content = ActiveFedora::Base.find("sufia:test1", cast: true).content.content
           expect(controller).to receive(:send_file_headers!).with({filename: 'world.png', disposition: 'inline', type: 'image/png' })
-          get "show", id: "test1", disposition: "inline"
-          expect(response.body).to eq(expected_content)
+          get "show", id: file, disposition: "inline"
+          expect(response.body).to eq expected_content
           expect(response).to be_success
         end
 
         it "should allow you to specify filename for download" do
-          allow(controller).to receive(:render) # send_data calls render internally
-          expected_content = ActiveFedora::Base.find("sufia:test1", cast: true).content.content
           expect(controller).to receive(:send_file_headers!).with({filename: 'my%20dog.png', disposition: 'inline', type: 'image/png' })
-          get "show", id: "test1", "filename" => "my%20dog.png"
-          expect(response.body).to eq(expected_content)
+          get "show", id: file, "filename" => "my%20dog.png"
+          expect(response.body).to eq expected_content
+          expect(response).to be_success
         end
       end
     end
@@ -60,15 +67,13 @@ describe DownloadsController, :type => :controller do
     describe "when not logged in as reader" do
       before do
         sign_in FactoryGirl.find_or_create(:jill)
-        allow_any_instance_of(User).to receive(:groups).and_return([])
-        allow(controller).to receive(:clear_session_user) ## Don't clear out the authenticated session
       end
 
       describe "show" do
         it "should deny access" do
-          get "show", id: "test1"
+          get "show", id: file
           expect(response).to redirect_to root_path
-          expect(flash[:alert]).to eq('You are not authorized to access this page.')
+          expect(flash[:alert]).to eq 'You are not authorized to access this page.'
         end
       end
     end

data/spec/controllers/generic_files_controller_spec.rb

@@ -1,295 +1,272 @@
 require 'spec_helper'
 
-describe GenericFilesController, :type => :controller do
+describe GenericFilesController do
+  let(:user) { FactoryGirl.find_or_create(:jill) }
   before do
     allow(controller).to receive(:has_access?).and_return(true)
-    @user = FactoryGirl.find_or_create(:jill)
-    sign_in @user
+    sign_in user
     allow_any_instance_of(User).to receive(:groups).and_return([])
     allow(controller).to receive(:clear_session_user) ## Don't clear out the authenticated session
+    allow_any_instance_of(GenericFile).to receive(:characterize)
   end
 
   describe "#create" do
-    before do
-      @file_count = GenericFile.count
-      @mock = GenericFile.new({ pid: 'test:123' })
-      allow(GenericFile).to receive(:new).and_return(@mock)
-    end
+    context "when uploading a file" do
+      let(:mock) { GenericFile.new(id: 'test123') }
+      let(:batch) { Batch.create }
+      let(:batch_id) { batch.id }
+      let(:file) { fixture_file_upload('/world.png','image/png') }
 
-    after do
-      begin
-        allow(GenericFile).to receive(:new).and_call_original
-      rescue RSpec::Mocks::MockExpectationError => e
+      before do
+        allow(GenericFile).to receive(:new).and_return(mock)
       end
-      Batch.find("sample:batch_id").delete rescue
-      @mock.delete unless @mock.inner_object.class == ActiveFedora::UnsavedDigitalObject
-    end
-
-    it "should record on_behalf_of" do
-      file = fixture_file_upload('/world.png','image/png')
-      xhr :post, :create, files: [file], Filename: 'The world', batch_id: 'sample:batch_id', on_behalf_of: 'carolyn', terms_of_service: '1'
-      expect(response).to be_success
-      saved_file = GenericFile.find('test:123')
-      expect(saved_file.on_behalf_of).to eq('carolyn')
-    end
 
-    it "should render error the file wasn't actually a file" do
-      file = 'hello'
-      xhr :post, :create, files: [file], Filename: "The World", batch_id: 'sample:batch_id', permission: {"group"=>{"public"=>"read"} }, terms_of_service: '1'
-      expect(response.status).to eq(422)
-      expect(JSON.parse(response.body).first['error']).to match(/no file for upload/i)
-    end
+      it "should record on_behalf_of" do
+        file = fixture_file_upload('/world.png','image/png')
+        xhr :post, :create, files: [file], Filename: 'The world', batch_id: batch_id, on_behalf_of: 'carolyn', terms_of_service: '1'
+        expect(response).to be_success
+        saved_file = GenericFile.find('test123')
+        expect(saved_file.on_behalf_of).to eq 'carolyn'
+      end
 
-    it "spawns a content deposit event job" do
-      file = fixture_file_upload('/world.png','image/png')
-      s1 = double('one')
-      allow(ContentDepositEventJob).to receive(:new).with('test:123', 'jilluser@example.com').and_return(s1)
-      expect(Sufia.queue).to receive(:push).with(s1).once
+      context "when the file submitted isn't a file" do
+        let(:file) { 'hello' }
 
-      s2 = double('one')
-      allow(CharacterizeJob).to receive(:new).with('test:123').and_return(s2)
-      expect(Sufia.queue).to receive(:push).with(s2).once
-      xhr :post, :create, files: [file], 'Filename' => 'The world', batch_id: 'sample:batch_id', permission: {group: { public: 'read' } }, terms_of_service: '1'
-      expect(flash[:error]).to be_nil
-    end
+        it "should render 422 error" do
+          xhr :post, :create, files: [file], Filename: "The World", batch_id: 'sample_batch_id', permission: {"group"=>{"public"=>"read"} }, terms_of_service: '1'
+          expect(response.status).to eq 422
+          expect(JSON.parse(response.body).first['error']).to match(/no file for upload/i)
+        end
+      end
 
-    it "displays a flash error when file has a virus" do
-      file = fixture_file_upload('/world.png', 'image/png')
-      expect(Sufia::GenericFile::Actor).to receive(:virus_check).with(file.path).and_raise(Sufia::VirusFoundError.new('A virus was found'))
-      xhr :post, :create, files: [file], Filename: "The world", batch_id: "sample:batch_id", permission: {"group"=>{"public"=>"read"} }, terms_of_service: '1'
-      expect(flash[:error]).not_to be_blank
-      expect(flash[:error]).to include('A virus was found')
-    end
+      context "when everything is perfect" do
+        it "spawns a content deposit event job" do
+          expect_any_instance_of(Sufia::GenericFile::Actor).to receive(:create_content).with(file, 'world.png', 'content').and_return(true)
+          xhr :post, :create, files: [file], 'Filename' => 'The world', batch_id: batch_id, permission: {group: { public: 'read' } }, terms_of_service: '1'
+          expect(flash[:error]).to be_nil
+        end
 
-    it "should create and save a file asset from the given params" do
-      date_today = Date.today
-      allow(Date).to receive(:today).and_return(date_today)
-      file = fixture_file_upload('/world.png','image/png')
-      xhr :post, :create, files: [file], Filename: "The world", batch_id: "sample:batch_id", permission: {"group"=>{"public"=>"read"} }, terms_of_service: '1'
-      expect(response).to be_success
-      expect(GenericFile.count).to eq(@file_count + 1)
+        it "should create and save a file asset from the given params" do
+          # Now expecting iso8601 dates?
+          date_today = Time.now.utc.iso8601
+          allow(Date).to receive(:today).and_return(date_today)
+          expect {
+            xhr :post, :create, files: [file], Filename: "The world", batch_id: batch_id,
+                      permission: {"group"=>{"public"=>"read"} }, terms_of_service: '1'
+          }.to change { GenericFile.count }.by(1)
+          expect(response).to be_success
 
-      saved_file = GenericFile.find('test:123')
+          saved_file = GenericFile.find('test123')
 
-      # This is confirming that the correct file was attached
-      expect(saved_file.label).to eq('world.png')
-      expect(saved_file.content.checksum).to eq('f794b23c0c6fe1083d0ca8b58261a078cd968967')
-      expect(saved_file.content.dsChecksumValid).to be true
+          # This is confirming that the correct file was attached
+          expect(saved_file.label).to eq 'world.png'
+          file.rewind
+          expect(saved_file.content.content).to eq (file.read)
+          # Confirming that date_uploaded and date_modified were set
+          expect(saved_file.date_uploaded).to eq date_today
+          expect(saved_file.date_modified).to eq date_today
+        end
 
-      # Confirming that date_uploaded and date_modified were set
-      expect(saved_file.date_uploaded).to eq(date_today)
-      expect(saved_file.date_modified).to eq(date_today)
-    end
+        it "should record what user created the first version of content" do
+          xhr :post, :create, files: [file], Filename: "The world", batch_id: batch_id, permission: {"group"=>{"public"=>"read"} }, terms_of_service: "1"
+          expect(VersionCommitter.pluck(:committer_login).last).to eq user.user_key
+        end
 
-    it "should record what user created the first version of content" do
-      file = fixture_file_upload('/world.png','image/png')
-      xhr :post, :create, files: [file], Filename: "The world", batch_id: "sample:batch_id", permission: {"group"=>{"public"=>"read"} }, terms_of_service: "1"
-      saved_file = GenericFile.find('test:123')
-      version = saved_file.content.latest_version
-      expect(version.versionID).to eq("content.0")
-      expect(saved_file.content.version_committer(version)).to eq(@user.user_key)
-    end
+        it "should set the depositor id" do
+          xhr :post, :create, files: [file], Filename: "The world", batch_id: batch_id, permission: {"group"=>{"public"=>"read"} }, terms_of_service: "1"
+          expect(response).to be_success
 
-    it "should create batch associations from batch_id" do
-      allow(Sufia.config).to receive(:id_namespace).and_return('sample')
-      file = fixture_file_upload('/world.png','image/png')
-      allow(controller).to receive(:add_posted_blob_to_asset)
-      xhr :post, :create, files: [file], Filename: "The world", batch_id: "sample:batch_id", permission: {"group"=>{"public"=>"read"} }, terms_of_service: "1"
-      allow(GenericFile).to receive(:new).and_call_original
-      expect {Batch.find("sample:batch_id")}.to raise_error(ActiveFedora::ObjectNotFoundError) # The controller shouldn't actually save the Batch, but it should write the batch id to the files.
-      batch = Batch.create(pid: "sample:batch_id")
-      expect(batch.generic_files.first.pid).to eq("test:123")
-    end
-    it "should set the depositor id" do
-      file = fixture_file_upload('/world.png','image/png')
-      xhr :post, :create, files: [file], Filename: "The world", batch_id: "sample:batch_id", permission: {"group"=>{"public"=>"read"} }, terms_of_service: "1"
-      expect(response).to be_success
+          saved_file = GenericFile.find('test123')
+          # This is confirming that apply_depositor_metadata recorded the depositor
+          expect(saved_file.depositor).to eq 'jilluser@example.com'
+          expect(saved_file.to_solr['depositor_tesim']).to eq ['jilluser@example.com']
+        end
+      end
 
-      saved_file = GenericFile.find('test:123')
-      # This is confirming that apply_depositor_metadata recorded the depositor
-      #TODO make sure this is moved to scholarsphere:
-      #saved_file.properties.depositor.should == ['jilluser']
-      expect(saved_file.properties.depositor).to eq(['jilluser@example.com'])
-      #TODO make sure this is moved to scholarsphere:
-      #saved_file.depositor.should == 'jilluser'
-      expect(saved_file.depositor).to eq('jilluser@example.com')
-      expect(saved_file.properties.to_solr.keys).to include('depositor_tesim')
-      #TODO make sure this is moved to scholarsphere:
-      #saved_file.properties.to_solr['depositor_t'].should == ['jilluser']
-      expect(saved_file.properties.to_solr['depositor_tesim']).to eq(['jilluser@example.com'])
-      expect(saved_file.to_solr.keys).to include('depositor_tesim')
-      expect(saved_file.to_solr['depositor_tesim']).to eq(['jilluser@example.com'])
-    end
+      context "when the file has a virus" do
+        it "displays a flash error when file has a virus" do
+          expect(Sufia::GenericFile::Actor).to receive(:virus_check).with(file.path).and_raise(Sufia::VirusFoundError.new('A virus was found'))
+          xhr :post, :create, files: [file], Filename: "The world", batch_id: "sample_batch_id", permission: {"group"=>{"public"=>"read"} }, terms_of_service: '1'
+          expect(flash[:error]).not_to be_blank
+          expect(flash[:error]).to include('A virus was found')
+        end
+      end
 
-    it "should error out of create and save after on continuos rsolr error" do
-      allow_any_instance_of(GenericFile).to receive(:save).and_raise(RSolr::Error::Http.new({},{}))
+      context "when solr continuously has errors" do
+        it "should error out of create and save after on continuos rsolr error" do
+          allow_any_instance_of(GenericFile).to receive(:save).and_raise(RSolr::Error::Http.new({},{}))
 
-      file = fixture_file_upload('/world.png','image/png')
-      xhr :post, :create, files: [file], Filename: "The world", batch_id: "sample:batch_id", permission: {"group"=>{"public"=>"read"} }, terms_of_service: "1"
-      expect(response.body).to include("Error occurred while creating generic file.")
+          file = fixture_file_upload('/world.png','image/png')
+          xhr :post, :create, files: [file], Filename: "The world", batch_id: "sample_batch_id", permission: {"group"=>{"public"=>"read"} }, terms_of_service: "1"
+          expect(response.body).to include("Error occurred while creating generic file.")
+        end
+      end
     end
-  end
 
-  describe "#create with browse-everything" do
-    before do
-      GenericFile.delete_all
-      @json_from_browse_everything = {"0"=>{"url"=>"https://dl.dropbox.com/fake/blah-blah.filepicker-demo.txt.txt", "expires"=>"2014-03-31T20:37:36.214Z", "file_name"=>"filepicker-demo.txt.txt"}, "1"=>{"url"=>"https://dl.dropbox.com/fake/blah-blah.Getting%20Started.pdf", "expires"=>"2014-03-31T20:37:36.731Z", "file_name"=>"Getting+Started.pdf"}}
-    end
-    it "should ingest files from provide URLs" do
-      expect(ImportUrlJob).to receive(:new).twice {"ImportJob"}
-      expect(Sufia.queue).to receive(:push).with("ImportJob").twice
-      expect { post :create, selected_files: @json_from_browse_everything, batch_id: "sample:batch_id" }.to change(GenericFile, :count).by(2)
-      created_files = GenericFile.all
-      ["https://dl.dropbox.com/fake/blah-blah.Getting%20Started.pdf", "https://dl.dropbox.com/fake/blah-blah.filepicker-demo.txt.txt"].each do |url|
-        expect(created_files.map {|f| f.import_url}).to include(url)
+    context "with browse-everything" do
+      let(:batch) { Batch.create }
+      let(:batch_id) { batch.id }
+
+      before do
+        @json_from_browse_everything = {"0"=>{"url"=>"https://dl.dropbox.com/fake/blah-blah.filepicker-demo.txt.txt", "expires"=>"2014-03-31T20:37:36.214Z", "file_name"=>"filepicker-demo.txt.txt"}, "1"=>{"url"=>"https://dl.dropbox.com/fake/blah-blah.Getting%20Started.pdf", "expires"=>"2014-03-31T20:37:36.731Z", "file_name"=>"Getting+Started.pdf"}}
       end
-      ["filepicker-demo.txt.txt","Getting+Started.pdf"].each do |filename|
-        expect(created_files.map {|f| f.label}).to include(filename)
+      it "should ingest files from provide URLs" do
+        expect(ImportUrlJob).to receive(:new).twice {"ImportJob"}
+        expect(Sufia.queue).to receive(:push).with("ImportJob").twice
+        expect { post :create, selected_files: @json_from_browse_everything, batch_id: batch_id }.to change(GenericFile, :count).by(2)
+        created_files = GenericFile.all
+        ["https://dl.dropbox.com/fake/blah-blah.Getting%20Started.pdf", "https://dl.dropbox.com/fake/blah-blah.filepicker-demo.txt.txt"].each do |url|
+          expect(created_files.map {|f| f.import_url}).to include(url)
+        end
+        ["filepicker-demo.txt.txt","Getting+Started.pdf"].each do |filename|
+          expect(created_files.map {|f| f.label}).to include(filename)
+        end
       end
     end
-  end
 
-  describe "#create with local_file" do
-    let (:mock_url) {"http://example.com"}
-    before do
-      Sufia.config.enable_local_ingest = true
-      GenericFile.delete_all
-      @mock_upload_directory = 'spec/mock_upload_directory'
-      # Dir.mkdir @mock_upload_directory unless File.exists? @mock_upload_directory
-      FileUtils.mkdir_p([File.join(@mock_upload_directory, "import/files"),File.join(@mock_upload_directory, "import/metadata")])
-      FileUtils.copy(File.expand_path('../../fixtures/world.png', __FILE__), @mock_upload_directory)
-      FileUtils.copy(File.expand_path('../../fixtures/image.jpg', __FILE__), @mock_upload_directory)
-      FileUtils.copy(File.expand_path('../../fixtures/dublin_core_rdf_descMetadata.nt', __FILE__), File.join(@mock_upload_directory, "import/metadata"))
-      FileUtils.copy(File.expand_path('../../fixtures/icons.zip', __FILE__), File.join(@mock_upload_directory, "import/files"))
-      FileUtils.copy(File.expand_path('../../fixtures/Example.ogg', __FILE__), File.join(@mock_upload_directory, "import/files"))
-    end
-    after do
-      Sufia.config.enable_local_ingest = false
-      allow_any_instance_of(FileContentDatastream).to receive(:live?).and_return(true)
-      GenericFile.destroy_all
-    end
-    context "when User model defines a directory path" do
+    context "with local_file" do
+      let(:mock_url) {"http://example.com"}
+      let(:mock_upload_directory) { 'spec/mock_upload_directory' }
+      let(:batch) { Batch.create }
+      let(:batch_id) { batch.id }
+
       before do
-        if $in_travis
-          # In order to avoid an invalid derivative creation, just stub out the derivatives.
-          allow_any_instance_of(GenericFile).to receive(:create_derivatives)
+        Sufia.config.enable_local_ingest = true
+        FileUtils.mkdir_p([File.join(mock_upload_directory, "import/files"), File.join(mock_upload_directory, "import/metadata")])
+        FileUtils.copy(File.expand_path('../../fixtures/world.png', __FILE__), mock_upload_directory)
+        FileUtils.copy(File.expand_path('../../fixtures/image.jpg', __FILE__), mock_upload_directory)
+        FileUtils.copy(File.expand_path('../../fixtures/dublin_core_rdf_descMetadata.nt', __FILE__), File.join(mock_upload_directory, "import/metadata"))
+        FileUtils.copy(File.expand_path('../../fixtures/icons.zip', __FILE__), File.join(mock_upload_directory, "import/files"))
+        FileUtils.copy(File.expand_path('../../fixtures/Example.ogg', __FILE__), File.join(mock_upload_directory, "import/files"))
+      end
+
+      after do
+        Sufia.config.enable_local_ingest = false
+        allow_any_instance_of(FileContentDatastream).to receive(:live?).and_return(true)
+      end
+
+      context "when User model defines a directory path" do
+        before do
+          allow_any_instance_of(User).to receive(:directory).and_return(mock_upload_directory)
         end
-        allow_any_instance_of(User).to receive(:directory).and_return(@mock_upload_directory)
-      end
-      it "should ingest files from the filesystem" do
-        expect { post :create, local_file: ["world.png", "image.jpg"], batch_id: "xw42n7934"}.to change(GenericFile, :count).by(2)
-        expect(response).to redirect_to Sufia::Engine.routes.url_helpers.batch_edit_path('xw42n7934')
-        # These files should have been moved out of the upload directory
-        expect(File).not_to exist("#{@mock_upload_directory}/image.jpg")
-        expect(File).not_to exist("#{@mock_upload_directory}/world.png")
-        # And into the storage directory
-        files = GenericFile.find(Solrizer.solr_name("is_part_of",:symbol) => 'info:fedora/sufia:xw42n7934')
-        expect(files.first.label).to eq('world.png')
-        expect(files.last.label).to eq('image.jpg')
-      end
-      it "should ingest redirect to another location" do
-        expect(GenericFilesController).to receive(:upload_complete_path).and_return(mock_url)
-        expect { post :create, local_file: ["world.png"], batch_id: "xw42n7934"}.to change(GenericFile, :count).by(1)
-        expect(response).to redirect_to mock_url
-        # These files should have been moved out of the upload directory
-        expect(File).not_to exist("#{@mock_upload_directory}/world.png")
-        # And into the storage directory
-        files = GenericFile.find(Solrizer.solr_name("is_part_of",:symbol) => 'info:fedora/sufia:xw42n7934')
-        expect(files.first.label).to eq('world.png')
-      end
-      it "should ingest directories from the filesystem" do
-        expect { post :create, local_file: ["world.png", "import"], batch_id: "xw42n7934"}.to change(GenericFile, :count).by(4)
-        expect(response).to redirect_to Sufia::Engine.routes.url_helpers.batch_edit_path('xw42n7934')
-        # These files should have been moved out of the upload directory
-        expect(File).not_to exist("#{@mock_upload_directory}/import/files/icons.zip")
-        expect(File).not_to exist("#{@mock_upload_directory}/import/metadata/dublin_core_rdf_descMetadata.nt")
-        expect(File).not_to exist("#{@mock_upload_directory}/world.png")
-        # And into the storage directory
-        files = GenericFile.find(Solrizer.solr_name("is_part_of",:symbol) => 'info:fedora/sufia:xw42n7934')
-        expect(files.first.label).to eq('world.png')
-        ['icons.zip', 'Example.ogg'].each do |filename|
-          expect(files.select{|f| f.label == filename}.first.relative_path).to eq("import/files/#{filename}")
+
+        it "should ingest files from the filesystem" do
+          expect {
+            post :create, local_file: ["world.png", "image.jpg"], batch_id: batch_id
+          }.to change(GenericFile, :count).by(2)
+          expect(response).to redirect_to Sufia::Engine.routes.url_helpers.batch_edit_path(batch_id)
+          # These files should have been moved out of the upload directory
+          expect(File).not_to exist("#{mock_upload_directory}/image.jpg")
+          expect(File).not_to exist("#{mock_upload_directory}/world.png")
+          # And into the storage directory
+          files = Batch.find(batch_id).generic_files
+          expect(files.first.label).to eq('world.png')
+          expect(files.to_a.map(&:label)).to eq ['world.png', 'image.jpg']
+        end
+
+        it "should ingest redirect to another location" do
+          expect(GenericFilesController).to receive(:upload_complete_path).and_return(mock_url)
+          expect {
+            post :create, local_file: ["world.png"], batch_id: batch_id
+          }.to change(GenericFile, :count).by(1)
+          expect(response).to redirect_to mock_url
+          # These files should have been moved out of the upload directory
+          expect(File).not_to exist("#{mock_upload_directory}/world.png")
+          # And into the storage directory
+          files = Batch.find(batch_id).generic_files
+          expect(files.first.label).to eq 'world.png'
+        end
+
+        it "should ingest directories from the filesystem" do
+          expect {
+            post :create, local_file: ["world.png", "import"], batch_id: batch_id
+          }.to change(GenericFile, :count).by(4)
+          expect(response).to redirect_to Sufia::Engine.routes.url_helpers.batch_edit_path(batch_id)
+          # These files should have been moved out of the upload directory
+          expect(File).not_to exist("#{mock_upload_directory}/import/files/icons.zip")
+          expect(File).not_to exist("#{mock_upload_directory}/import/metadata/dublin_core_rdf_descMetadata.nt")
+          expect(File).not_to exist("#{mock_upload_directory}/world.png")
+          # And into the storage directory
+          files = Batch.find(batch_id).generic_files
+          expect(files.first.label).to eq 'world.png'
+          # TODO: use files.select once projecthydra/active_fedora#609 is fixed
+          ['icons.zip', 'Example.ogg'].each do |filename|
+            expect(files.map { |f| f.relative_path if f.label.match(filename) }.compact.first).to eq "import/files/#{filename}"
+          end
+          expect(files.map { |f| f.relative_path if f.label.match("dublin_core_rdf_descMetadata.nt") }.compact.first).to eq 'import/metadata/dublin_core_rdf_descMetadata.nt'
         end
-        expect(files.select{|f| f.label == 'dublin_core_rdf_descMetadata.nt'}.first.relative_path).to eq('import/metadata/dublin_core_rdf_descMetadata.nt')
       end
-    end
-    context "when User model does not define directory path" do
-      it "should return an error message and redirect to file upload page" do
-        expect { post :create, local_file: ["world.png", "image.jpg"], batch_id: "xw42n7934"}.not_to change(GenericFile, :count)
-        expect(response).to render_template :new
-        expect(flash[:alert]).to eq('Your account is not configured for importing files from a user-directory on the server.')
+
+      context "when User model does not define directory path" do
+        it "should return an error message and redirect to file upload page" do
+          expect {
+            post :create, local_file: ["world.png", "image.jpg"], batch_id: batch_id
+          }.to_not change(GenericFile, :count)
+          expect(response).to render_template :new
+          expect(flash[:alert]).to eq 'Your account is not configured for importing files from a user-directory on the server.'
+        end
       end
     end
   end
 
   describe "audit" do
-    before do
-      @generic_file = GenericFile.new
-      @generic_file.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
-      @generic_file.apply_depositor_metadata('mjg36')
-      @generic_file.save
-    end
-    after do
-      @generic_file.delete
+    let(:generic_file) do
+      GenericFile.create do |gf|
+        gf.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
+        gf.apply_depositor_metadata(user)
+      end
     end
+
     it "should return json with the result" do
-      xhr :post, :audit, id: @generic_file.pid
+      xhr :post, :audit, id: generic_file
       expect(response).to be_success
-      expect { JSON.parse(response.body) }.not_to raise_error
-      audit_results = JSON.parse(response.body).collect { |result| result["pass"] }
-      expect(audit_results.reduce(true) { |sum, value| sum && value }).to be_truthy
+      json = JSON.parse(response.body)
+      audit_results = json.collect { |result| result["pass"] }
+      expect(audit_results.reduce(true) { |sum, value| sum && value }).to eq 999 # never been audited
     end
   end
 
   describe "destroy" do
-    before(:each) do
-      @generic_file = GenericFile.new
-      @generic_file.apply_depositor_metadata(@user)
-      @generic_file.save
-      @user = FactoryGirl.find_or_create(:jill)
-      sign_in @user
+    let(:generic_file) do
+      GenericFile.create do |gf|
+        gf.apply_depositor_metadata(user)
+      end
     end
-    after do
-      @user.delete
+
+    before do
+      allow(ContentDeleteEventJob).to receive(:new).with(generic_file.id, user.user_key).and_return(delete_message)
     end
+    let(:delete_message) { double('delete message') }
     it "should delete the file" do
-      expect(GenericFile.find(@generic_file.pid)).not_to be_nil
-      delete :destroy, id: @generic_file.pid
-      expect { GenericFile.find(@generic_file.pid) }.to raise_error(ActiveFedora::ObjectNotFoundError)
-    end
-    it "should spawn a content delete event job" do
-      s1 = double('one')
-      expect(ContentDeleteEventJob).to receive(:new).with(@generic_file.pid, @user.user_key).and_return(s1)
-      expect(Sufia.queue).to receive(:push).with(s1).once
-      delete :destroy, id: @generic_file.pid
+      expect(Sufia.queue).to receive(:push).with(delete_message)
+      expect {
+        delete :destroy, id: generic_file
+      }.to change { GenericFile.exists?(generic_file.id) }.from(true).to(false)
     end
 
     context "when the file is featured" do
       before do
-        FeaturedWork.create(generic_file_id: @generic_file.pid)
+        FeaturedWork.create(generic_file_id: generic_file.id)
+        expect(Sufia.queue).to receive(:push).with(delete_message)
       end
       it "should make the file not featured" do
-        expect(FeaturedWorkList.new.featured_works.map(&:generic_file_id)).to include(@generic_file.pid)
-        delete :destroy, id: @generic_file.pid
-        expect(FeaturedWorkList.new.featured_works.map(&:generic_file_id)).to_not include(@generic_file.pid)
+        expect(FeaturedWorkList.new.featured_works.map(&:generic_file_id)).to include(generic_file.id)
+        delete :destroy, id: generic_file.id
+        expect(FeaturedWorkList.new.featured_works.map(&:generic_file_id)).to_not include(generic_file.id)
       end
     end
   end
 
   describe 'stats' do
-    before do
-      @generic_file = GenericFile.new.tap do |gf|
-        gf.apply_depositor_metadata(@user)
-        gf.save
+    let(:generic_file) do
+      GenericFile.create do |gf|
+        gf.apply_depositor_metadata(user)
       end
     end
 
-    after do
-      @generic_file.destroy
-    end
-
     context 'when user has access to file' do
       before do
+        sign_in user
         mock_query = double('query')
         allow(mock_query).to receive(:for_path).and_return([
             OpenStruct.new(date: '2014-01-01', pageviews: 4),
@@ -304,31 +281,26 @@ describe GenericFilesController, :type => :controller do
 
         download_query = double('query')
         allow(download_query).to receive(:for_file).and_return([
-          OpenStruct.new(date: Date.today.strftime("%Y%m%d"), eventCategory: "Files", eventAction: "Downloaded", eventLabel: "sufia:123456789", totalEvents: "3")
+          OpenStruct.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "123456789", totalEvents: "3")
         ])
         allow(download_query).to receive(:map).and_return(download_query.for_file.map(&:marshal_dump))
         allow(profile).to receive(:sufia__download).and_return(download_query)
       end
 
       it 'renders the stats view' do
-        allow(controller.request).to receive(:referer).and_return('foo')
-        expect(controller).to receive(:add_breadcrumb).with(I18n.t('sufia.dashboard.title'), Sufia::Engine.routes.url_helpers.dashboard_index_path)
-        expect(controller).to receive(:add_breadcrumb).with(I18n.t('sufia.dashboard.my.files'), Sufia::Engine.routes.url_helpers.dashboard_files_path)
-        expect(controller).to receive(:add_breadcrumb).with(I18n.t('sufia.generic_file.browse_view'), Sufia::Engine.routes.url_helpers.generic_file_path(@generic_file.noid))
-        get :stats, id: @generic_file.noid
+        get :stats, id: generic_file
         expect(response).to be_success
         expect(response).to render_template(:stats)
       end
 
       context "user is not signed in but the file is public" do
         before do
-          sign_out @user
-          @generic_file.read_groups = ['public']
-          @generic_file.save
+          generic_file.read_groups = ['public']
+          generic_file.save
         end
 
         it 'renders the stats view' do
-          get :stats, id: @generic_file.noid
+          get :stats, id: generic_file
           expect(response).to be_success
           expect(response).to render_template(:stats)
         end
@@ -337,186 +309,176 @@ describe GenericFilesController, :type => :controller do
 
     context 'when user lacks access to file' do
       before do
-        @archivist = FactoryGirl.find_or_create(:archivist)
-        sign_in @archivist
+        sign_in FactoryGirl.create(:user)
       end
 
       it 'redirects to root_url' do
-        get :stats, id: @generic_file.pid
+        get :stats, id: generic_file
         expect(response).to redirect_to(Sufia::Engine.routes.url_helpers.root_path)
       end
     end
   end
 
-  describe "update" do
+  describe "#edit" do
     let(:generic_file) do
-      GenericFile.new.tap do |gf|
-        gf.apply_depositor_metadata(@user)
-        gf.save!
+      GenericFile.create do |gf|
+        gf.apply_depositor_metadata(user)
       end
     end
 
-    after do
-      generic_file.destroy
-    end
-
-    it "should spawn a content update event job" do
-      s1 = double('one')
-      expect(ContentUpdateEventJob).to receive(:new).with(generic_file.pid, 'jilluser@example.com').and_return(s1)
-      expect(Sufia.queue).to receive(:push).with(s1).once
-      @user = FactoryGirl.find_or_create(:jill)
-      sign_in @user
-      post :update, id: generic_file, generic_file: {title: ['new_title'], tag: [''], permissions: { new_user_name: {'archivist1'=>'edit'}}}
-      @user.delete
-    end
-
-    it "spawns a content new version event job" do
-      s1 = double('one')
-      allow(ContentNewVersionEventJob).to receive(:new).with(generic_file.pid, 'jilluser@example.com').and_return(s1)
-      expect(Sufia.queue).to receive(:push).with(s1).once
-
-      s2 = double('one')
-      allow(CharacterizeJob).to receive(:new).with(generic_file.pid).and_return(s2)
-      expect(Sufia.queue).to receive(:push).with(s2).once
-      @user = FactoryGirl.find_or_create(:jill)
-      sign_in @user
+    it "should set the versions presenter" do
+      get :edit, id: generic_file
 
-      file = fixture_file_upload('/world.png', 'image/png')
-      post :update, id: generic_file, filedata: file, generic_file: {tag: [''], permissions: { new_user_name: {archivist1: 'edit' } } }
-      @user.destroy
+      expect(response).to be_success
+      expect(assigns[:generic_file]).to eq generic_file
+      expect(assigns[:version_list]).to be_kind_of Sufia::VersionListPresenter
     end
 
-    it "should change mime type when restoring a revision with a different mime type" do
-      @user = FactoryGirl.find_or_create(:jill)
-      sign_in @user
-
-      file = fixture_file_upload('/world.png','image/png')
-      post :update, id: generic_file, filedata: file, generic_file: { tag: [''], permissions: { new_user_name: { 'archivist1@example.com'=>'edit' } } }
-
-      posted_file = GenericFile.find(generic_file.pid)
-      version1 = posted_file.content.latest_version
-      expect(posted_file.content.version_committer(version1)).to eq(@user.user_key)
-
-      file = fixture_file_upload('/image.jpg','image/jpg')
-      post :update, id: generic_file, filedata: file, generic_file: { tag: [''], permissions: { new_user_name: { 'archivist1@example.com'=>'edit' } } }
-
-      posted_file = GenericFile.find(generic_file.pid)
-      version2 = posted_file.content.latest_version
-      expect(posted_file.content.version_committer(version2)).to eq(@user.user_key)
-
-      expect(posted_file.content.mimeType).to eq("image/jpeg")
-      post :update, id: generic_file, revision: 'content.0'
+  end
 
-      restored_file = GenericFile.find(generic_file.pid)
-      version3 = restored_file.content.latest_version
-      expect(version3.versionID).not_to eq(version2.versionID)
-      expect(version3.versionID).not_to eq(version1.versionID)
-      expect(restored_file.content.version_committer(version3)).to eq(@user.user_key)
-      expect(restored_file.content.mimeType).to eq("image/png")
-      @user.delete
+  describe "update" do
+    let(:generic_file) do
+      GenericFile.create do |gf|
+        gf.apply_depositor_metadata(user)
+      end
     end
 
-    context "when two users edit a file" do
-      let(:archivist) { FactoryGirl.find_or_create(:archivist) }
-      let(:user) { FactoryGirl.find_or_create(:jill) }
-      let(:generic_file) do
-        GenericFile.new.tap do |gf|
-          gf.apply_depositor_metadata(user)
-          gf.edit_users = [user.user_key, archivist.user_key]
-          gf.save!
-        end
-      end
+    context "when updating metadata" do
+      let(:update_message) { double('content update message') }
       before do
-        allow_any_instance_of(Sufia::GenericFile::Actor).to receive(:push_characterize_job)
-        sign_in user
+        allow(ContentUpdateEventJob).to receive(:new).with(generic_file.id, 'jilluser@example.com').and_return(update_message)
       end
 
-      it "records which user added a new version" do
-        file = fixture_file_upload('/world.png','image/png')
-        post :update, id: generic_file, filedata: file
-
-        posted_file = GenericFile.find(generic_file.pid)
-        version1 = posted_file.content.latest_version
-        expect(posted_file.content.version_committer(version1)).to eq(user.user_key)
+      it "should spawn a content update event job" do
+        expect(Sufia.queue).to receive(:push).with(update_message)
+        post :update, id: generic_file, generic_file: { title: ['new_title'], tag: [''],
+                                                        permissions_attributes: [{ type: 'person', name: 'archivist1', access: 'edit'}] }
+      end
 
-        # other user uploads new version
-        # TODO this should be a separate test
-        allow(controller).to receive(:current_user).and_return(archivist)
-        # reset controller:
-        controller.instance_variable_set(:@actor, nil)
+      it "spawns a content new version event job" do
+        s1 = double('one')
+        allow(ContentNewVersionEventJob).to receive(:new).with(generic_file.id, 'jilluser@example.com').and_return(s1)
+        expect(Sufia.queue).to receive(:push).with(s1).once
 
-        expect(ContentUpdateEventJob).to receive(:new).with(generic_file.pid, 'jilluser@example.com').never
+        s2 = double('one')
+        allow(CharacterizeJob).to receive(:new).with(generic_file.id).and_return(s2)
+        expect(Sufia.queue).to receive(:push).with(s2).once
+        file = fixture_file_upload('/world.png', 'image/png')
+        post :update, id: generic_file, filedata: file, generic_file: {tag: [''], permissions: { new_user_name: {archivist1: 'edit' } } }
+      end
+    end
 
+    context "when updating the attached file" do
+      it "spawns a content new version event job" do
         s1 = double('one')
-        allow(ContentNewVersionEventJob).to receive(:new).with(generic_file.pid, archivist.user_key).and_return(s1)
+        allow(ContentNewVersionEventJob).to receive(:new).with(generic_file.id, 'jilluser@example.com').and_return(s1)
         expect(Sufia.queue).to receive(:push).with(s1).once
 
-        file = fixture_file_upload('/image.jpg', 'image/jpg')
-        post :update, id: generic_file, filedata: file
+        s2 = double('one')
+        allow(CharacterizeJob).to receive(:new).with(generic_file.id).and_return(s2)
+        expect(Sufia.queue).to receive(:push).with(s2).once
 
-        edited_file = generic_file.reload
-        version2 = edited_file.content.latest_version
-        expect(version2.versionID).not_to eq(version1.versionID)
-        expect(edited_file.content.version_committer(version2)).to eq(archivist.user_key)
+        file = fixture_file_upload('/world.png', 'image/png')
+        post :update, id: generic_file, filedata: file, generic_file: {tag: [''],
+                                                        permissions_attributes: [{ type: 'user', name: 'archivist1', access: 'edit'}] }
+      end
+    end
 
-        # original user restores his or her version
-        allow(controller).to receive(:current_user).and_return(user)
-        sign_in user
-        expect(ContentUpdateEventJob).to receive(:new).with(generic_file.pid, 'jilluser@example.com').never
-        s1 = double('one')
-        allow(ContentRestoredVersionEventJob).to receive(:new).with(generic_file.pid, user.user_key, 'content.0').and_return(s1)
-        expect(Sufia.queue).to receive(:push).with(s1).once
+    context "with two existing versions from different users" do
+
+      let(:file1)       { "world.png" }
+      let(:file1_type)  { "image/png" }
+      let(:file2)       { "image.jpg" }
+      let(:file2_type)  { "image/jpeg" }
+      let(:second_user) { FactoryGirl.create(:user) }
+      let(:version1)    { "version1" }
+      let(:actor1)      { Sufia::GenericFile::Actor.new(generic_file, user) }
+      let(:actor2)      { Sufia::GenericFile::Actor.new(generic_file, second_user) }
 
-        # reset controller:
-        controller.instance_variable_set(:@actor, nil)
+      before do
+        allow_any_instance_of(GenericFile).to receive(:characterize)
+        actor1.create_content(fixture_file_upload(file1), file1, 'content')
+        actor2.create_content(fixture_file_upload(file2), file2, 'content')
+      end
 
-        post :update, id: generic_file, revision: 'content.0'
+      describe "restoring a previous version" do
+        context "as the first user" do
+          before do
+            sign_in user
+            post :update, id: generic_file, revision: version1
+          end
+
+          let(:restored_content) { generic_file.reload.content }
+          let(:versions)         { restored_content.versions }
+          let(:latest_version)   { restored_content.latest_version }
+
+          it "should restore the first versions's content and metadata" do
+            expect(restored_content.mime_type).to eq file1_type
+            expect(restored_content.original_name).to eq file1
+            expect(versions.all.count).to eq 3
+            expect(versions.last.label).to eq latest_version.label
+            expect(VersionCommitter.where(version_id: versions.last.uri).pluck(:committer_login)).to eq [user.user_key]
+          end
+        end
 
-        restored_file = generic_file.reload
-        version3 = restored_file.content.latest_version
-        expect(version3.versionID).not_to eq(version2.versionID)
-        expect(version3.versionID).not_to eq(version1.versionID)
-        expect(restored_file.content.version_committer(version3)).to eq(user.user_key)
+        context "as the second user" do
+          before do
+            sign_in second_user
+          end
+          it "should not create a new version" do
+            post :update, id: generic_file, revision: version1
+            expect(response).to be_redirect
+          end
+        end
       end
     end
 
     it "should add new groups and users" do
-      post :update, id: generic_file, generic_file: { tag: [''], permissions:
-        { new_group_name: { 'group1' => 'read' }, new_user_name: { 'user1' => 'edit' }}}
+      post :update, id: generic_file,
+        generic_file: { tag: [''],
+                        permissions_attributes: [
+                          { type: 'person', name: 'user1', access: 'edit' },
+                          { type: 'group', name: 'group1', access: 'read' }
+                        ]
+                      }
 
-      expect(assigns[:generic_file].read_groups).to eq(["group1"])
-      expect(assigns[:generic_file].edit_users).to include("user1", @user.user_key)
+      expect(assigns[:generic_file].read_groups).to eq ["group1"]
+      expect(assigns[:generic_file].edit_users).to include("user1", user.user_key)
     end
+
     it "should update existing groups and users" do
-      generic_file.read_groups = ['group3']
+      generic_file.edit_groups = ['group3']
       generic_file.save
-      post :update, id: generic_file, generic_file: { tag: [''], permissions:
-        { new_group_name: '', new_group_permission: '', new_user_name: '', new_user_permission: '', group: { 'group3' => 'read' }}}
+      post :update, id: generic_file,
+        generic_file: { tag: [''],
+                        permissions_attributes: [
+                          { id: generic_file.permissions.last.id, type: 'group', name: 'group3', access: 'read'}
+                        ]
+                      }
 
       expect(assigns[:generic_file].read_groups).to eq(["group3"])
     end
 
     it "spawns a virus check" do
       s1 = double('one')
-      allow(ContentNewVersionEventJob).to receive(:new).with(generic_file.pid, 'jilluser@example.com').and_return(s1)
+      allow(ContentNewVersionEventJob).to receive(:new).with(generic_file.id, 'jilluser@example.com').and_return(s1)
       expect(Sufia.queue).to receive(:push).with(s1).once
 
       s2 = double('one')
-      allow(CharacterizeJob).to receive(:new).with(generic_file.pid).and_return(s2)
-      allow(CreateDerivativesJob).to receive(:new).with(generic_file.pid).and_return(s2)
-      @user = FactoryGirl.find_or_create(:jill)
-      sign_in @user
+      allow(CharacterizeJob).to receive(:new).with(generic_file.id).and_return(s2)
+      allow(CreateDerivativesJob).to receive(:new).with(generic_file.id).and_return(s2)
       file = fixture_file_upload('/world.png', 'image/png')
       expect(Sufia::GenericFile::Actor).to receive(:virus_check).and_return(0)
       expect(Sufia.queue).to receive(:push).with(s2).once
-      post :update, id: generic_file.pid, filedata: file, 'Filename' => 'The world', generic_file: { tag: [''], permissions: { new_user_name: { archivist1: 'edit' } } }
+      post :update, id: generic_file.id, filedata: file, 'Filename' => 'The world',
+          generic_file: { tag: [''],
+                          permissions_attributes: [{ type: 'user', name: 'archivist1', access: 'edit' }] }
     end
 
     context "when there's an error saving" do
       let!(:generic_file) do
-        GenericFile.new.tap do |gf|
-          gf.apply_depositor_metadata(@user)
-          gf.save!
+        GenericFile.create do |gf|
+          gf.apply_depositor_metadata(user)
         end
       end
       it "redirects to edit" do
@@ -529,88 +491,61 @@ describe GenericFilesController, :type => :controller do
     end
   end
 
-  describe "edit" do
+  describe "someone elses files" do
     let(:generic_file) do
-      GenericFile.new.tap do |gf|
-        gf.apply_depositor_metadata(@user)
-        gf.save!
+      GenericFile.create(id: 'test5') do |f|
+        f.apply_depositor_metadata('archivist1@example.com')
+        f.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
+        # grant public read access explicitly
+        f.read_groups = ['public']
       end
     end
 
-    after do
-      generic_file.destroy
-    end
-
-    it 'renders the edit view' do
-      allow(controller.request).to receive(:referer).and_return('foo')
-      expect(controller).to receive(:add_breadcrumb).with(I18n.t('sufia.dashboard.title'), Sufia::Engine.routes.url_helpers.dashboard_index_path)
-      expect(controller).to receive(:add_breadcrumb).with(I18n.t('sufia.dashboard.my.files'), Sufia::Engine.routes.url_helpers.dashboard_files_path)
-      expect(controller).to receive(:add_breadcrumb).with(I18n.t('sufia.generic_file.browse_view'), Sufia::Engine.routes.url_helpers.generic_file_path(generic_file.noid))
-      get :edit, id: generic_file.noid
-      expect(response).to be_success
-      expect(response).to render_template(:edit)
-    end
-  end
-  describe "someone elses files" do
-    before do
-      f = GenericFile.new(pid: 'sufia:test5')
-      f.apply_depositor_metadata('archivist1@example.com')
-      f.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
-      # grant public read access explicitly
-      f.read_groups = ['public']
-      f.save
-      @file = f
-      allow_any_instance_of(Sufia::GenericFile::Actor).to receive(:push_characterize_job)
-    end
-    after do
-      GenericFile.find('sufia:test5').destroy
-    end
     describe "edit" do
       it "should give me a flash error" do
-        get :edit, id: "test5"
+        get :edit, id: generic_file
         expect(response).to redirect_to @routes.url_helpers.generic_file_path('test5')
         expect(flash[:alert]).not_to be_nil
         expect(flash[:alert]).not_to be_empty
         expect(flash[:alert]).to include("You do not have sufficient privileges to edit this document")
       end
     end
-    describe "view" do
-      it "should show me the file" do
-        get :show, id: "test5"
-        expect(response).not_to redirect_to(action: 'show')
-        expect(flash[:alert]).to be_nil
-      end
-      it "should set the breadcrumbs" do
+
+    describe "#show" do
+      it "should show me the file and set breadcrumbs" do
         expect(controller).to receive(:add_breadcrumb).with(I18n.t('sufia.dashboard.title'), Sufia::Engine.routes.url_helpers.dashboard_index_path)
-        get :show, id: "test5"
+        get :show, id: generic_file
+        expect(response).to be_successful
+        expect(flash).to be_empty
+        expect(assigns[:events]).to be_kind_of Array
+        expect(assigns[:generic_file]).to eq generic_file
+        expect(assigns[:audit_status]).to eq 'Audits have not yet been run on this file.'
       end
     end
-    describe "flash" do
-      it "should not let the user submit if they logout" do
-        sign_out @user
-        get :new
-        expect(response).not_to be_success
-        expect(flash[:alert]).not_to be_nil
-        expect(flash[:alert]).to include("You need to sign in or sign up before continuing")
-      end
-      it "should filter flash if they signin" do
-        sign_in @user
-        get :show, id: "test5"
-        expect(flash[:alert]).to be_nil
-      end
-      describe "failing audit" do
-        before do
-          allow_any_instance_of(ActiveFedora::RelsExtDatastream).to receive(:dsChecksumValid).and_return(false)
-          @archivist = FactoryGirl.find_or_create(:archivist)
-        end
-        it "should display failing audits" do
-          sign_in @archivist
-          AuditJob.new(@file.pid, "RELS-EXT", @file.rels_ext.versionID).run
-          get :show, id: "test5"
-          expect(assigns[:notify_number]).to eq(1)
-          expect(@archivist.mailbox.inbox[0].messages[0].subject).to eq("Failing Audit Run")
-        end
-      end
+  end
+
+  describe "flash" do
+    it "should not let the user submit if they logout" do
+      sign_out user
+      get :new
+      expect(response).to_not be_success
+      expect(flash[:alert]).to include("You need to sign in or sign up before continuing")
+    end
+    it "should filter flash if they signin" do
+      sign_in user
+      get :new
+      expect(flash[:alert]).to be_nil
+    end
+  end
+
+  describe "notifications" do
+    before do
+      User.audituser.send_message(user, "Test message", "Test subject")
+    end
+    it "should display notifications" do
+      get :new
+      expect(assigns[:notify_number]).to eq 1
+      expect(user.mailbox.inbox[0].messages[0].subject).to eq "Test subject"
     end
   end
 end